feat(package): update scripts

feat(app): remove backend
feat(app): add upload functionality
2025-09-17 14:51:32 +00:00 · 2025-03-19 16:34:55 +05:30 · 2025-03-19 16:23:27 +05:30 · 2025-03-19 15:32:32 +05:30 · 2025-03-19 13:42:28 +05:30 · 2025-03-19 13:42:15 +05:30
116 changed files with 4925 additions and 7124 deletions
--- a/ui/.eslintrc.json
+++ b/ui/.eslintrc.json
--- a/.gitignore
+++ b/.gitignore
@@ -4,9 +4,9 @@ npm-debug.log
 yarn-error.log

 # Build output
-/.next/
-/out/
-/dist/
+.next/
+out/
+dist/

 # IDE/Editor specific
 .vscode/
--- a/.prettierrc.js
+++ b/.prettierrc.js
@@ -6,7 +6,6 @@ const config = {
  endOfLine: 'auto',
  singleQuote: true,
  tabWidth: 2,
-  semi: true,
 };

 module.exports = config;
--- a/README.md
+++ b/README.md
@@ -1,7 +1,22 @@
 # 🚀 Perplexica - An AI-powered search engine 🔎 <!-- omit in toc -->

-[![Discord](https://dcbadge.vercel.app/api/server/26aArMy8tT?style=flat&compact=true)](https://discord.gg/26aArMy8tT)
+<div align="center" markdown="1">
+   <sup>Special thanks to:</sup>
+   <br>
+   <br>
+   <a href="https://www.warp.dev/perplexica">
+      <img alt="Warp sponsorship" width="400" src="https://github.com/user-attachments/assets/775dd593-9b5f-40f1-bf48-479faff4c27b">
+   </a>

+### [Warp, the AI Devtool that lives in your terminal](https://www.warp.dev/perplexica)
+
+[Available for MacOS, Linux, & Windows](https://www.warp.dev/perplexica)
+
+</div>
+
+<hr/>
+
+[![Discord](https://dcbadge.vercel.app/api/server/26aArMy8tT?style=flat&compact=true)](https://discord.gg/26aArMy8tT)

 ![preview](.assets/perplexica-screenshot.png?)

@@ -44,7 +59,7 @@ Want to know more about its architecture and how it works? You can read it [here
  - **Normal Mode:** Processes your query and performs a web search.
 - **Focus Modes:** Special modes to better answer specific types of questions. Perplexica currently has 6 focus modes:
  - **All Mode:** Searches the entire web to find the best results.
-  - **Writing Assistant Mode:** Helpful for writing tasks that does not require searching the web.
+  - **Writing Assistant Mode:** Helpful for writing tasks that do not require searching the web.
  - **Academic Search Mode:** Finds articles and papers, ideal for academic research.
  - **YouTube Search Mode:** Finds YouTube videos based on the search query.
  - **Wolfram Alpha Search Mode:** Answers queries that need calculations or data analysis using Wolfram Alpha.
@@ -143,6 +158,7 @@ You can access Perplexica over your home network by following our networking gui

 ## One-Click Deployment

+[![Deploy to Sealos](https://raw.githubusercontent.com/labring-actions/templates/main/Deploy-on-Sealos.svg)](https://usw.sealos.io/?openapp=system-template%3FtemplateName%3Dperplexica)
 [![Deploy to RepoCloud](https://d16t0pc4846x52.cloudfront.net/deploylobe.svg)](https://repocloud.io/details/?app_id=267)

 ## Upcoming Features
--- a/app.dockerfile
+++ b/app.dockerfile
@@ -1,13 +1,20 @@
 FROM node:20.18.0-alpine

-ARG NEXT_PUBLIC_WS_URL=ws://127.0.0.1:3001
-ARG NEXT_PUBLIC_API_URL=http://127.0.0.1:3001/api
-ENV NEXT_PUBLIC_WS_URL=${NEXT_PUBLIC_WS_URL}
-ENV NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL}
-
 WORKDIR /home/perplexica

-COPY ui /home/perplexica/
+COPY src /home/perplexica/src
+COPY public /home/perplexica/public
+COPY package.json /home/perplexica/package.json
+COPY yarn.lock /home/perplexica/yarn.lock
+COPY tsconfig.json /home/perplexica/tsconfig.json
+COPY next.config.mjs /home/perplexica/next.config.mjs
+COPY next-env.d.ts /home/perplexica/next-env.d.ts
+COPY postcss.config.js /home/perplexica/postcss.config.js
+COPY drizzle.config.ts /home/perplexica/drizzle.config.ts
+COPY tailwind.config.ts /home/perplexica/tailwind.config.ts
+
+RUN mkdir /home/perplexica/data
+RUN mkdir /home/perplexica/uploads

 RUN yarn install --frozen-lockfile
 RUN yarn build
--- a/backend.dockerfile
+++ b/backend.dockerfile
@@ -1,17 +0,0 @@
-FROM node:18-slim
-
-WORKDIR /home/perplexica
-
-COPY src /home/perplexica/src
-COPY tsconfig.json /home/perplexica/
-COPY drizzle.config.ts /home/perplexica/
-COPY package.json /home/perplexica/
-COPY yarn.lock /home/perplexica/
-
-RUN mkdir /home/perplexica/data
-RUN mkdir /home/perplexica/uploads
-
-RUN yarn install --frozen-lockfile --network-timeout 600000
-RUN yarn build
-
-CMD ["yarn", "start"]
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -9,41 +9,20 @@ services:
      - perplexica-network
    restart: unless-stopped

-  perplexica-backend:
-    build:
-      context: .
-      dockerfile: backend.dockerfile
-    image: itzcrazykns1337/perplexica-backend:main
-    environment:
-      - SEARXNG_API_URL=http://searxng:8080
-    depends_on:
-      - searxng
-    ports:
-      - 3001:3001
-    volumes:
-      - backend-dbstore:/home/perplexica/data
-      - uploads:/home/perplexica/uploads
-      - ./config.toml:/home/perplexica/config.toml
-    extra_hosts:
-      - 'host.docker.internal:host-gateway'
-    networks:
-      - perplexica-network
-    restart: unless-stopped
-
-  perplexica-frontend:
+  app:
    build:
      context: .
      dockerfile: app.dockerfile
-      args:
-        - NEXT_PUBLIC_API_URL=http://127.0.0.1:3001/api
-        - NEXT_PUBLIC_WS_URL=ws://127.0.0.1:3001
-    image: itzcrazykns1337/perplexica-frontend:main
-    depends_on:
-      - perplexica-backend
+    environment:
+      - SEARXNG_API_URL=http://searxng:8080
    ports:
      - 3000:3000
    networks:
      - perplexica-network
+    volumes:
+      - backend-dbstore:/home/perplexica/data
+      - uploads:/home/perplexica/uploads
+      - ./config.toml:/home/perplexica/config.toml
    restart: unless-stopped

 networks:
--- a/docs/installation/UPDATING.md
+++ b/docs/installation/UPDATING.md
@@ -7,34 +7,43 @@ To update Perplexica to the latest version, follow these steps:
 1. Clone the latest version of Perplexica from GitHub:

   ```bash
-      git clone https://github.com/ItzCrazyKns/Perplexica.git
+   git clone https://github.com/ItzCrazyKns/Perplexica.git
   ```

-2. Navigate to the Project Directory.
+2. Navigate to the project directory.

-3. Pull latest images from registry.
+3. Check for changes in the configuration files. If the `sample.config.toml` file contains new fields, delete your existing `config.toml` file, rename `sample.config.toml` to `config.toml`, and update the configuration accordingly.
+
+4. Pull the latest images from the registry.

   ```bash
   docker compose pull
   ```

-4. Update and Recreate containers.
+5. Update and recreate the containers.

   ```bash
   docker compose up -d
   ```

-5. Once the command completes running go to http://localhost:3000 and verify the latest changes.
+6. Once the command completes, go to http://localhost:3000 and verify the latest changes.

-## For non Docker users
+## For non-Docker users

 1. Clone the latest version of Perplexica from GitHub:

   ```bash
-      git clone https://github.com/ItzCrazyKns/Perplexica.git
+   git clone https://github.com/ItzCrazyKns/Perplexica.git
   ```

-2. Navigate to the Project Directory
-3. Execute `npm i` in both the `ui` folder and the root directory.
-4. Once packages are updated, execute `npm run build` in both the `ui` folder and the root directory.
-5. Finally, start both the frontend and the backend by running `npm run start` in both the `ui` folder and the root directory.
+2. Navigate to the project directory.
+
+3. Check for changes in the configuration files. If the `sample.config.toml` file contains new fields, delete your existing `config.toml` file, rename `sample.config.toml` to `config.toml`, and update the configuration accordingly.
+
+4. Execute `npm i` in both the `ui` folder and the root directory.
+
+5. Once the packages are updated, execute `npm run build` in both the `ui` folder and the root directory.
+
+6. Finally, start both the frontend and the backend by running `npm run start` in both the `ui` folder and the root directory.
+
+---
--- a/drizzle.config.ts
+++ b/drizzle.config.ts
@@ -2,7 +2,7 @@ import { defineConfig } from 'drizzle-kit';

 export default defineConfig({
  dialect: 'sqlite',
-  schema: './src/db/schema.ts',
+  schema: './src/lib/db/schema.ts',
  out: './drizzle',
  dbCredentials: {
    url: './data/db.sqlite',
--- a/next-env.d.ts
+++ b/next-env.d.ts
@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
--- a/ui/next.config.mjs
+++ b/ui/next.config.mjs
@@ -7,6 +7,7 @@ const nextConfig = {
      },
    ],
  },
+  serverExternalPackages: ['pdf-parse'],
 };

 export default nextConfig;
--- a/package.json
+++ b/package.json
@@ -1,53 +1,62 @@
 {
-  "name": "perplexica-backend",
+  "name": "perplexica-frontend",
  "version": "1.10.0-rc3",
  "license": "MIT",
  "author": "ItzCrazyKns",
  "scripts": {
-    "start": "npm run db:push && node dist/app.js",
-    "build": "tsc",
-    "dev": "nodemon --ignore uploads/ src/app.ts ",
-    "db:push": "drizzle-kit push sqlite",
-    "format": "prettier . --check",
-    "format:write": "prettier . --write"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.10",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^4.17.21",
-    "@types/html-to-text": "^9.0.4",
-    "@types/multer": "^1.4.12",
-    "@types/pdf-parse": "^1.1.4",
-    "@types/readable-stream": "^4.0.11",
-    "@types/ws": "^8.5.12",
-    "drizzle-kit": "^0.22.7",
-    "nodemon": "^3.1.0",
-    "prettier": "^3.2.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.4.3"
+    "dev": "next dev",
+    "build": "next build",
+    "start": "npm run db:push && next start",
+    "lint": "next lint",
+    "format:write": "prettier . --write",
+    "db:push": "drizzle-kit push"
  },
  "dependencies": {
+    "@headlessui/react": "^2.2.0",
    "@iarna/toml": "^2.2.5",
-    "@langchain/anthropic": "^0.2.3",
-    "@langchain/community": "^0.2.16",
+    "@icons-pack/react-simple-icons": "^12.3.0",
+    "@langchain/community": "^0.3.36",
+    "@langchain/core": "^0.3.42",
    "@langchain/openai": "^0.0.25",
-    "@langchain/google-genai": "^0.0.23",
-    "@xenova/transformers": "^2.17.1",
-    "axios": "^1.6.8",
-    "better-sqlite3": "^11.0.0",
+    "@langchain/textsplitters": "^0.1.0",
+    "@tailwindcss/typography": "^0.5.12",
+    "axios": "^1.8.3",
+    "better-sqlite3": "^11.9.1",
+    "clsx": "^2.1.0",
    "compute-cosine-similarity": "^1.1.0",
    "compute-dot": "^1.1.0",
-    "cors": "^2.8.5",
-    "dotenv": "^16.4.5",
-    "drizzle-orm": "^0.31.2",
-    "express": "^4.19.2",
+    "drizzle-orm": "^0.40.1",
    "html-to-text": "^9.0.5",
    "langchain": "^0.1.30",
-    "mammoth": "^1.8.0",
-    "multer": "^1.4.5-lts.1",
+    "lucide-react": "^0.363.0",
+    "markdown-to-jsx": "^7.7.2",
+    "next": "^15.2.2",
+    "next-themes": "^0.3.0",
    "pdf-parse": "^1.1.1",
-    "winston": "^3.13.0",
-    "ws": "^8.17.1",
+    "react": "^18",
+    "react-dom": "^18",
+    "react-text-to-speech": "^0.14.5",
+    "react-textarea-autosize": "^8.5.3",
+    "sonner": "^1.4.41",
+    "tailwind-merge": "^2.2.2",
+    "winston": "^3.17.0",
+    "yet-another-react-lightbox": "^3.17.2",
    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/html-to-text": "^9.0.4",
+    "@types/node": "^20",
+    "@types/pdf-parse": "^1.1.4",
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "autoprefixer": "^10.0.1",
+    "drizzle-kit": "^0.30.5",
+    "eslint": "^8",
+    "eslint-config-next": "14.1.4",
+    "postcss": "^8",
+    "prettier": "^3.2.5",
+    "tailwindcss": "^3.3.0",
+    "typescript": "^5"
  }
 }
--- a/ui/postcss.config.js
+++ b/ui/postcss.config.js
--- a/ui/public/next.svg
+++ b/ui/public/next.svg
--- a/ui/public/vercel.svg
+++ b/ui/public/vercel.svg
--- a/sample.config.toml
+++ b/sample.config.toml
@@ -18,9 +18,10 @@ API_KEY = ""
 [MODELS.CUSTOM_OPENAI]
 API_KEY = ""
 API_URL = ""
+MODEL_NAME = ""

 [MODELS.OLLAMA]
 API_URL = "" # Ollama API URL - http://host.docker.internal:11434

 [API_ENDPOINTS]
-SEARXNG = "http://localhost:32768" # SearxNG API URL
+SEARXNG = "" # SearxNG API URL - http://localhost:32768
--- a/src/app.ts
+++ b/src/app.ts
@@ -1,38 +0,0 @@
-import { startWebSocketServer } from './websocket';
-import express from 'express';
-import cors from 'cors';
-import http from 'http';
-import routes from './routes';
-import { getPort } from './config';
-import logger from './utils/logger';
-
-const port = getPort();
-
-const app = express();
-const server = http.createServer(app);
-
-const corsOptions = {
-  origin: '*',
-};
-
-app.use(cors(corsOptions));
-app.use(express.json());
-
-app.use('/api', routes);
-app.get('/api', (_, res) => {
-  res.status(200).json({ status: 'ok' });
-});
-
-server.listen(port, () => {
-  logger.info(`Server is running on port ${port}`);
-});
-
-startWebSocketServer(server);
-
-process.on('uncaughtException', (err, origin) => {
-  logger.error(`Uncaught Exception at ${origin}: ${err}`);
-});
-
-process.on('unhandledRejection', (reason, promise) => {
-  logger.error(`Unhandled Rejection at: ${promise}, reason: ${reason}`);
-});
--- a/src/app/api/chat/route.ts
+++ b/src/app/api/chat/route.ts
@@ -0,0 +1,360 @@
+import prompts from '@/lib/prompts';
+import MetaSearchAgent from '@/lib/search/metaSearchAgent';
+import crypto from 'crypto';
+import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
+import { EventEmitter } from 'stream';
+import {
+  chatModelProviders,
+  embeddingModelProviders,
+  getAvailableChatModelProviders,
+  getAvailableEmbeddingModelProviders,
+} from '@/lib/providers';
+import db from '@/lib/db';
+import { chats, messages as messagesSchema } from '@/lib/db/schema';
+import { and, eq, gt } from 'drizzle-orm';
+import { getFileDetails } from '@/lib/utils/files';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ChatOpenAI } from '@langchain/openai';
+import {
+  getCustomOpenaiApiKey,
+  getCustomOpenaiApiUrl,
+  getCustomOpenaiModelName,
+} from '@/lib/config';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const searchHandlers: Record<string, MetaSearchAgent> = {
+  webSearch: new MetaSearchAgent({
+    activeEngines: [],
+    queryGeneratorPrompt: prompts.webSearchRetrieverPrompt,
+    responsePrompt: prompts.webSearchResponsePrompt,
+    rerank: true,
+    rerankThreshold: 0.3,
+    searchWeb: true,
+    summarizer: true,
+  }),
+  academicSearch: new MetaSearchAgent({
+    activeEngines: ['arxiv', 'google scholar', 'pubmed'],
+    queryGeneratorPrompt: prompts.academicSearchRetrieverPrompt,
+    responsePrompt: prompts.academicSearchResponsePrompt,
+    rerank: true,
+    rerankThreshold: 0,
+    searchWeb: true,
+    summarizer: false,
+  }),
+  writingAssistant: new MetaSearchAgent({
+    activeEngines: [],
+    queryGeneratorPrompt: '',
+    responsePrompt: prompts.writingAssistantPrompt,
+    rerank: true,
+    rerankThreshold: 0,
+    searchWeb: false,
+    summarizer: false,
+  }),
+  wolframAlphaSearch: new MetaSearchAgent({
+    activeEngines: ['wolframalpha'],
+    queryGeneratorPrompt: prompts.wolframAlphaSearchRetrieverPrompt,
+    responsePrompt: prompts.wolframAlphaSearchResponsePrompt,
+    rerank: false,
+    rerankThreshold: 0,
+    searchWeb: true,
+    summarizer: false,
+  }),
+  youtubeSearch: new MetaSearchAgent({
+    activeEngines: ['youtube'],
+    queryGeneratorPrompt: prompts.youtubeSearchRetrieverPrompt,
+    responsePrompt: prompts.youtubeSearchResponsePrompt,
+    rerank: true,
+    rerankThreshold: 0.3,
+    searchWeb: true,
+    summarizer: false,
+  }),
+  redditSearch: new MetaSearchAgent({
+    activeEngines: ['reddit'],
+    queryGeneratorPrompt: prompts.redditSearchRetrieverPrompt,
+    responsePrompt: prompts.redditSearchResponsePrompt,
+    rerank: true,
+    rerankThreshold: 0.3,
+    searchWeb: true,
+    summarizer: false,
+  }),
+};
+
+type Message = {
+  messageId: string;
+  chatId: string;
+  content: string;
+};
+
+type ChatModel = {
+  provider: string;
+  name: string;
+};
+
+type EmbeddingModel = {
+  provider: string;
+  name: string;
+};
+
+type Body = {
+  message: Message;
+  optimizationMode: 'speed' | 'balanced' | 'quality';
+  focusMode: string;
+  history: Array<[string, string]>;
+  files: Array<string>;
+  chatModel: ChatModel;
+  embeddingModel: EmbeddingModel;
+};
+
+const handleEmitterEvents = async (
+  stream: EventEmitter,
+  writer: WritableStreamDefaultWriter,
+  encoder: TextEncoder,
+  aiMessageId: string,
+  chatId: string,
+) => {
+  let recievedMessage = '';
+  let sources: any[] = [];
+
+  stream.on('data', (data) => {
+    const parsedData = JSON.parse(data);
+    if (parsedData.type === 'response') {
+      writer.write(
+        encoder.encode(
+          JSON.stringify({
+            type: 'message',
+            data: parsedData.data,
+            messageId: aiMessageId,
+          }) + '\n',
+        ),
+      );
+
+      recievedMessage += parsedData.data;
+    } else if (parsedData.type === 'sources') {
+      writer.write(
+        encoder.encode(
+          JSON.stringify({
+            type: 'sources',
+            data: parsedData.data,
+            messageId: aiMessageId,
+          }) + '\n',
+        ),
+      );
+
+      sources = parsedData.data;
+    }
+  });
+  stream.on('end', () => {
+    writer.write(
+      encoder.encode(
+        JSON.stringify({
+          type: 'messageEnd',
+          messageId: aiMessageId,
+        }) + '\n',
+      ),
+    );
+    writer.close();
+
+    db.insert(messagesSchema)
+      .values({
+        content: recievedMessage,
+        chatId: chatId,
+        messageId: aiMessageId,
+        role: 'assistant',
+        metadata: JSON.stringify({
+          createdAt: new Date(),
+          ...(sources && sources.length > 0 && { sources }),
+        }),
+      })
+      .execute();
+  });
+  stream.on('error', (data) => {
+    const parsedData = JSON.parse(data);
+    writer.write(
+      encoder.encode(
+        JSON.stringify({
+          type: 'error',
+          data: parsedData.data,
+        }),
+      ),
+    );
+    writer.close();
+  });
+};
+
+const handleHistorySave = async (
+  message: Message,
+  humanMessageId: string,
+  focusMode: string,
+  files: string[],
+) => {
+  const chat = await db.query.chats.findFirst({
+    where: eq(chats.id, message.chatId),
+  });
+
+  if (!chat) {
+    await db
+      .insert(chats)
+      .values({
+        id: message.chatId,
+        title: message.content,
+        createdAt: new Date().toString(),
+        focusMode: focusMode,
+        files: files.map(getFileDetails),
+      })
+      .execute();
+  }
+
+  const messageExists = await db.query.messages.findFirst({
+    where: eq(messagesSchema.messageId, humanMessageId),
+  });
+
+  if (!messageExists) {
+    await db
+      .insert(messagesSchema)
+      .values({
+        content: message.content,
+        chatId: message.chatId,
+        messageId: humanMessageId,
+        role: 'user',
+        metadata: JSON.stringify({
+          createdAt: new Date(),
+        }),
+      })
+      .execute();
+  } else {
+    await db
+      .delete(messagesSchema)
+      .where(
+        and(
+          gt(messagesSchema.id, messageExists.id),
+          eq(messagesSchema.chatId, message.chatId),
+        ),
+      )
+      .execute();
+  }
+};
+
+export const POST = async (req: Request) => {
+  try {
+    const body = (await req.json()) as Body;
+    const { message } = body;
+
+    if (message.content === '') {
+      return Response.json(
+        {
+          message: 'Please provide a message to process',
+        },
+        { status: 400 },
+      );
+    }
+
+    const [chatModelProviders, embeddingModelProviders] = await Promise.all([
+      getAvailableChatModelProviders(),
+      getAvailableEmbeddingModelProviders(),
+    ]);
+
+    const chatModelProvider =
+      chatModelProviders[
+        body.chatModel?.provider || Object.keys(chatModelProviders)[0]
+      ];
+    const chatModel =
+      chatModelProvider[
+        body.chatModel?.name || Object.keys(chatModelProvider)[0]
+      ];
+
+    const embeddingProvider =
+      embeddingModelProviders[
+        body.embeddingModel?.provider || Object.keys(embeddingModelProviders)[0]
+      ];
+    const embeddingModel =
+      embeddingProvider[
+        body.embeddingModel?.name || Object.keys(embeddingProvider)[0]
+      ];
+
+    let llm: BaseChatModel | undefined;
+    let embedding = embeddingModel.model;
+
+    if (body.chatModel?.provider === 'custom_openai') {
+      llm = new ChatOpenAI({
+        openAIApiKey: getCustomOpenaiApiKey(),
+        modelName: getCustomOpenaiModelName(),
+        temperature: 0.7,
+        configuration: {
+          baseURL: getCustomOpenaiApiUrl(),
+        },
+      }) as unknown as BaseChatModel;
+    } else if (chatModelProvider && chatModel) {
+      llm = chatModel.model;
+    }
+
+    if (!llm) {
+      return Response.json({ error: 'Invalid chat model' }, { status: 400 });
+    }
+
+    if (!embedding) {
+      return Response.json(
+        { error: 'Invalid embedding model' },
+        { status: 400 },
+      );
+    }
+
+    const humanMessageId =
+      message.messageId ?? crypto.randomBytes(7).toString('hex');
+    const aiMessageId = crypto.randomBytes(7).toString('hex');
+
+    const history: BaseMessage[] = body.history.map((msg) => {
+      if (msg[0] === 'human') {
+        return new HumanMessage({
+          content: msg[1],
+        });
+      } else {
+        return new AIMessage({
+          content: msg[1],
+        });
+      }
+    });
+
+    const handler = searchHandlers[body.focusMode];
+
+    if (!handler) {
+      return Response.json(
+        {
+          message: 'Invalid focus mode',
+        },
+        { status: 400 },
+      );
+    }
+
+    const stream = await handler.searchAndAnswer(
+      message.content,
+      history,
+      llm,
+      embedding,
+      body.optimizationMode,
+      body.files,
+    );
+
+    const responseStream = new TransformStream();
+    const writer = responseStream.writable.getWriter();
+    const encoder = new TextEncoder();
+
+    handleEmitterEvents(stream, writer, encoder, aiMessageId, message.chatId);
+    handleHistorySave(message, humanMessageId, body.focusMode, body.files);
+
+    return new Response(responseStream.readable, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        Connection: 'keep-alive',
+        'Cache-Control': 'no-cache, no-transform',
+      },
+    });
+  } catch (err) {
+    console.error('An error ocurred while processing chat request:', err);
+    return Response.json(
+      { message: 'An error ocurred while processing chat request' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/api/chats/[id]/route.ts
+++ b/src/app/api/chats/[id]/route.ts
@@ -0,0 +1,69 @@
+import db from '@/lib/db';
+import { chats, messages } from '@/lib/db/schema';
+import { eq } from 'drizzle-orm';
+
+export const GET = async (
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+) => {
+  try {
+    const { id } = await params;
+
+    const chatExists = await db.query.chats.findFirst({
+      where: eq(chats.id, id),
+    });
+
+    if (!chatExists) {
+      return Response.json({ message: 'Chat not found' }, { status: 404 });
+    }
+
+    const chatMessages = await db.query.messages.findMany({
+      where: eq(messages.chatId, id),
+    });
+
+    return Response.json(
+      {
+        chat: chatExists,
+        messages: chatMessages,
+      },
+      { status: 200 },
+    );
+  } catch (err) {
+    console.error('Error in getting chat by id: ', err);
+    return Response.json(
+      { message: 'An error has occurred.' },
+      { status: 500 },
+    );
+  }
+};
+
+export const DELETE = async (
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+) => {
+  try {
+    const { id } = await params;
+
+    const chatExists = await db.query.chats.findFirst({
+      where: eq(chats.id, id),
+    });
+
+    if (!chatExists) {
+      return Response.json({ message: 'Chat not found' }, { status: 404 });
+    }
+
+    await db.delete(chats).where(eq(chats.id, id)).execute();
+    await db.delete(messages).where(eq(messages.chatId, id)).execute();
+
+    return Response.json(
+      { message: 'Chat deleted successfully' },
+      { status: 200 },
+    );
+  } catch (err) {
+    console.error('Error in deleting chat by id: ', err);
+    return Response.json(
+      { message: 'An error has occurred.' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/api/chats/route.ts
+++ b/src/app/api/chats/route.ts
@@ -0,0 +1,15 @@
+import db from '@/lib/db';
+
+export const GET = async (req: Request) => {
+  try {
+    let chats = await db.query.chats.findMany();
+    chats = chats.reverse();
+    return Response.json({ chats: chats }, { status: 200 });
+  } catch (err) {
+    console.error('Error in getting chats: ', err);
+    return Response.json(
+      { message: 'An error has occurred.' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/api/config/route.ts
+++ b/src/app/api/config/route.ts
@@ -1,26 +1,22 @@
-import express from 'express';
+import {
+  getAnthropicApiKey,
+  getCustomOpenaiApiKey,
+  getCustomOpenaiApiUrl,
+  getCustomOpenaiModelName,
+  getGeminiApiKey,
+  getGroqApiKey,
+  getOllamaApiEndpoint,
+  getOpenaiApiKey,
+  updateConfig,
+} from '@/lib/config';
 import {
  getAvailableChatModelProviders,
  getAvailableEmbeddingModelProviders,
-} from '../lib/providers';
-import {
-  getGroqApiKey,
-  getOllamaApiEndpoint,
-  getAnthropicApiKey,
-  getGeminiApiKey,
-  getOpenaiApiKey,
-  updateConfig,
-  getCustomOpenaiApiUrl,
-  getCustomOpenaiApiKey,
-  getCustomOpenaiModelName,
-} from '../config';
-import logger from '../utils/logger';
+} from '@/lib/providers';

-const router = express.Router();
-
-router.get('/', async (_, res) => {
+export const GET = async (req: Request) => {
  try {
-    const config = {};
+    const config: Record<string, any> = {};

    const [chatModelProviders, embeddingModelProviders] = await Promise.all([
      getAvailableChatModelProviders(),
@@ -61,44 +57,53 @@ router.get('/', async (_, res) => {
    config['customOpenaiApiKey'] = getCustomOpenaiApiKey();
    config['customOpenaiModelName'] = getCustomOpenaiModelName();

-    res.status(200).json(config);
-  } catch (err: any) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(`Error getting config: ${err.message}`);
+    return Response.json({ ...config }, { status: 200 });
+  } catch (err) {
+    console.error('An error ocurred while getting config:', err);
+    return Response.json(
+      { message: 'An error ocurred while getting config' },
+      { status: 500 },
+    );
  }
-});
+};

-router.post('/', async (req, res) => {
-  const config = req.body;
+export const POST = async (req: Request) => {
+  try {
+    const config = await req.json();

-  const updatedConfig = {
-    MODELS: {
-      OPENAI: {
-        API_KEY: config.openaiApiKey,
+    const updatedConfig = {
+      MODELS: {
+        OPENAI: {
+          API_KEY: config.openaiApiKey,
+        },
+        GROQ: {
+          API_KEY: config.groqApiKey,
+        },
+        ANTHROPIC: {
+          API_KEY: config.anthropicApiKey,
+        },
+        GEMINI: {
+          API_KEY: config.geminiApiKey,
+        },
+        OLLAMA: {
+          API_URL: config.ollamaApiUrl,
+        },
+        CUSTOM_OPENAI: {
+          API_URL: config.customOpenaiApiUrl,
+          API_KEY: config.customOpenaiApiKey,
+          MODEL_NAME: config.customOpenaiModelName,
+        },
      },
-      GROQ: {
-        API_KEY: config.groqApiKey,
-      },
-      ANTHROPIC: {
-        API_KEY: config.anthropicApiKey,
-      },
-      GEMINI: {
-        API_KEY: config.geminiApiKey,
-      },
-      OLLAMA: {
-        API_URL: config.ollamaApiUrl,
-      },
-      CUSTOM_OPENAI: {
-        API_URL: config.customOpenaiApiUrl,
-        API_KEY: config.customOpenaiApiKey,
-        MODEL_NAME: config.customOpenaiModelName,
-      },
-    },
-  };
+    };

-  updateConfig(updatedConfig);
+    updateConfig(updatedConfig);

-  res.status(200).json({ message: 'Config updated' });
-});
-
-export default router;
+    return Response.json({ message: 'Config updated' }, { status: 200 });
+  } catch (err) {
+    console.error('An error ocurred while updating config:', err);
+    return Response.json(
+      { message: 'An error ocurred while updating config' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/api/discover/route.ts
+++ b/src/app/api/discover/route.ts
@@ -0,0 +1,61 @@
+import { searchSearxng } from '@/lib/searxng';
+
+const articleWebsites = [
+  'yahoo.com',
+  'www.exchangewire.com',
+  'businessinsider.com',
+  /* 'wired.com',
+  'mashable.com',
+  'theverge.com',
+  'gizmodo.com',
+  'cnet.com',
+  'venturebeat.com', */
+];
+
+const topics = ['AI', 'tech']; /* TODO: Add UI to customize this */
+
+export const GET = async (req: Request) => {
+  try {
+    const data = (
+      await Promise.all([
+        ...new Array(articleWebsites.length * topics.length)
+          .fill(0)
+          .map(async (_, i) => {
+            return (
+              await searchSearxng(
+                `site:${articleWebsites[i % articleWebsites.length]} ${
+                  topics[i % topics.length]
+                }`,
+                {
+                  engines: ['bing news'],
+                  pageno: 1,
+                },
+              )
+            ).results;
+          }),
+      ])
+    )
+      .map((result) => result)
+      .flat()
+      .sort(() => Math.random() - 0.5);
+
+    return Response.json(
+      {
+        blogs: data,
+      },
+      {
+        status: 200,
+      },
+    );
+  } catch (err) {
+    console.error(`An error ocurred in discover route: ${err}`);
+    return Response.json(
+      {
+        message: 'An error has occurred',
+      },
+      {
+        status: 500,
+      },
+    );
+  }
+};
--- a/src/app/api/images/route.ts
+++ b/src/app/api/images/route.ts
@@ -0,0 +1,83 @@
+import handleImageSearch from '@/lib/chains/imageSearchAgent';
+import {
+  getCustomOpenaiApiKey,
+  getCustomOpenaiApiUrl,
+  getCustomOpenaiModelName,
+} from '@/lib/config';
+import { getAvailableChatModelProviders } from '@/lib/providers';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
+import { ChatOpenAI } from '@langchain/openai';
+
+interface ChatModel {
+  provider: string;
+  model: string;
+}
+
+interface ImageSearchBody {
+  query: string;
+  chatHistory: any[];
+  chatModel?: ChatModel;
+}
+
+export const POST = async (req: Request) => {
+  try {
+    const body: ImageSearchBody = await req.json();
+
+    const chatHistory = body.chatHistory
+      .map((msg: any) => {
+        if (msg.role === 'user') {
+          return new HumanMessage(msg.content);
+        } else if (msg.role === 'assistant') {
+          return new AIMessage(msg.content);
+        }
+      })
+      .filter((msg) => msg !== undefined) as BaseMessage[];
+
+    const chatModelProviders = await getAvailableChatModelProviders();
+
+    const chatModelProvider =
+      chatModelProviders[
+        body.chatModel?.provider || Object.keys(chatModelProviders)[0]
+      ];
+    const chatModel =
+      chatModelProvider[
+        body.chatModel?.model || Object.keys(chatModelProvider)[0]
+      ];
+
+    let llm: BaseChatModel | undefined;
+
+    if (body.chatModel?.provider === 'custom_openai') {
+      llm = new ChatOpenAI({
+        openAIApiKey: getCustomOpenaiApiKey(),
+        modelName: getCustomOpenaiModelName(),
+        temperature: 0.7,
+        configuration: {
+          baseURL: getCustomOpenaiApiUrl(),
+        },
+      }) as unknown as BaseChatModel;
+    } else if (chatModelProvider && chatModel) {
+      llm = chatModel.model;
+    }
+
+    if (!llm) {
+      return Response.json({ error: 'Invalid chat model' }, { status: 400 });
+    }
+
+    const images = await handleImageSearch(
+      {
+        chat_history: chatHistory,
+        query: body.query,
+      },
+      llm,
+    );
+
+    return Response.json({ images }, { status: 200 });
+  } catch (err) {
+    console.error(`An error ocurred while searching images: ${err}`);
+    return Response.json(
+      { message: 'An error ocurred while searching images' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/api/models/route.ts
+++ b/src/app/api/models/route.ts
@@ -0,0 +1,47 @@
+import {
+  getAvailableChatModelProviders,
+  getAvailableEmbeddingModelProviders,
+} from '@/lib/providers';
+
+export const GET = async (req: Request) => {
+  try {
+    const [chatModelProviders, embeddingModelProviders] = await Promise.all([
+      getAvailableChatModelProviders(),
+      getAvailableEmbeddingModelProviders(),
+    ]);
+
+    Object.keys(chatModelProviders).forEach((provider) => {
+      Object.keys(chatModelProviders[provider]).forEach((model) => {
+        delete (chatModelProviders[provider][model] as { model?: unknown })
+          .model;
+      });
+    });
+
+    Object.keys(embeddingModelProviders).forEach((provider) => {
+      Object.keys(embeddingModelProviders[provider]).forEach((model) => {
+        delete (embeddingModelProviders[provider][model] as { model?: unknown })
+          .model;
+      });
+    });
+
+    return Response.json(
+      {
+        chatModelProviders,
+        embeddingModelProviders,
+      },
+      {
+        status: 200,
+      },
+    );
+  } catch (err) {
+    console.error('An error ocurred while fetching models', err);
+    return Response.json(
+      {
+        message: 'An error has occurred.',
+      },
+      {
+        status: 500,
+      },
+    );
+  }
+};
--- a/src/app/api/suggestions/route.ts
+++ b/src/app/api/suggestions/route.ts
@@ -0,0 +1,81 @@
+import generateSuggestions from '@/lib/chains/suggestionGeneratorAgent';
+import {
+  getCustomOpenaiApiKey,
+  getCustomOpenaiApiUrl,
+  getCustomOpenaiModelName,
+} from '@/lib/config';
+import { getAvailableChatModelProviders } from '@/lib/providers';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
+import { ChatOpenAI } from '@langchain/openai';
+
+interface ChatModel {
+  provider: string;
+  model: string;
+}
+
+interface SuggestionsGenerationBody {
+  chatHistory: any[];
+  chatModel?: ChatModel;
+}
+
+export const POST = async (req: Request) => {
+  try {
+    const body: SuggestionsGenerationBody = await req.json();
+
+    const chatHistory = body.chatHistory
+      .map((msg: any) => {
+        if (msg.role === 'user') {
+          return new HumanMessage(msg.content);
+        } else if (msg.role === 'assistant') {
+          return new AIMessage(msg.content);
+        }
+      })
+      .filter((msg) => msg !== undefined) as BaseMessage[];
+
+    const chatModelProviders = await getAvailableChatModelProviders();
+
+    const chatModelProvider =
+      chatModelProviders[
+        body.chatModel?.provider || Object.keys(chatModelProviders)[0]
+      ];
+    const chatModel =
+      chatModelProvider[
+        body.chatModel?.model || Object.keys(chatModelProvider)[0]
+      ];
+
+    let llm: BaseChatModel | undefined;
+
+    if (body.chatModel?.provider === 'custom_openai') {
+      llm = new ChatOpenAI({
+        openAIApiKey: getCustomOpenaiApiKey(),
+        modelName: getCustomOpenaiModelName(),
+        temperature: 0.7,
+        configuration: {
+          baseURL: getCustomOpenaiApiUrl(),
+        },
+      }) as unknown as BaseChatModel;
+    } else if (chatModelProvider && chatModel) {
+      llm = chatModel.model;
+    }
+
+    if (!llm) {
+      return Response.json({ error: 'Invalid chat model' }, { status: 400 });
+    }
+
+    const suggestions = await generateSuggestions(
+      {
+        chat_history: chatHistory,
+      },
+      llm,
+    );
+
+    return Response.json({ suggestions }, { status: 200 });
+  } catch (err) {
+    console.error(`An error ocurred while generating suggestions: ${err}`);
+    return Response.json(
+      { message: 'An error ocurred while generating suggestions' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/api/uploads/route.ts
+++ b/src/app/api/uploads/route.ts
@@ -0,0 +1,134 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { getAvailableEmbeddingModelProviders } from '@/lib/providers';
+import { PDFLoader } from '@langchain/community/document_loaders/fs/pdf';
+import { DocxLoader } from '@langchain/community/document_loaders/fs/docx';
+import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
+import { Document } from 'langchain/document';
+
+interface FileRes {
+  fileName: string;
+  fileExtension: string;
+  fileId: string;
+}
+
+const uploadDir = path.join(process.cwd(), 'uploads');
+
+if (!fs.existsSync(uploadDir)) {
+  fs.mkdirSync(uploadDir, { recursive: true });
+}
+
+const splitter = new RecursiveCharacterTextSplitter({
+  chunkSize: 500,
+  chunkOverlap: 100,
+});
+
+export async function POST(req: Request) {
+  try {
+    const formData = await req.formData();
+
+    const files = formData.getAll('files') as File[];
+    const embedding_model = formData.get('embedding_model');
+    const embedding_model_provider = formData.get('embedding_model_provider');
+
+    if (!embedding_model || !embedding_model_provider) {
+      return NextResponse.json(
+        { message: 'Missing embedding model or provider' },
+        { status: 400 },
+      );
+    }
+
+    const embeddingModels = await getAvailableEmbeddingModelProviders();
+    const provider =
+      embedding_model_provider ?? Object.keys(embeddingModels)[0];
+    const embeddingModel =
+      embedding_model ?? Object.keys(embeddingModels[provider as string])[0];
+
+    let embeddingsModel =
+      embeddingModels[provider as string]?.[embeddingModel as string]?.model;
+    if (!embeddingsModel) {
+      return NextResponse.json(
+        { message: 'Invalid embedding model selected' },
+        { status: 400 },
+      );
+    }
+
+    const processedFiles: FileRes[] = [];
+
+    await Promise.all(
+      files.map(async (file: any) => {
+        const fileExtension = file.name.split('.').pop();
+        if (!['pdf', 'docx', 'txt'].includes(fileExtension!)) {
+          return NextResponse.json(
+            { message: 'File type not supported' },
+            { status: 400 },
+          );
+        }
+
+        const uniqueFileName = `${crypto.randomBytes(16).toString('hex')}.${fileExtension}`;
+        const filePath = path.join(uploadDir, uniqueFileName);
+
+        const buffer = Buffer.from(await file.arrayBuffer());
+        fs.writeFileSync(filePath, new Uint8Array(buffer));
+
+        let docs: any[] = [];
+        if (fileExtension === 'pdf') {
+          const loader = new PDFLoader(filePath);
+          docs = await loader.load();
+        } else if (fileExtension === 'docx') {
+          const loader = new DocxLoader(filePath);
+          docs = await loader.load();
+        } else if (fileExtension === 'txt') {
+          const text = fs.readFileSync(filePath, 'utf-8');
+          docs = [
+            new Document({ pageContent: text, metadata: { title: file.name } }),
+          ];
+        }
+
+        const splitted = await splitter.splitDocuments(docs);
+
+        const extractedDataPath = filePath.replace(/\.\w+$/, '-extracted.json');
+        fs.writeFileSync(
+          extractedDataPath,
+          JSON.stringify({
+            title: file.name,
+            contents: splitted.map((doc) => doc.pageContent),
+          }),
+        );
+
+        const embeddings = await embeddingsModel.embedDocuments(
+          splitted.map((doc) => doc.pageContent),
+        );
+        const embeddingsDataPath = filePath.replace(
+          /\.\w+$/,
+          '-embeddings.json',
+        );
+        fs.writeFileSync(
+          embeddingsDataPath,
+          JSON.stringify({
+            title: file.name,
+            embeddings,
+          }),
+        );
+
+        processedFiles.push({
+          fileName: file.name,
+          fileExtension: fileExtension,
+          fileId: uniqueFileName.replace(/\.\w+$/, ''),
+        });
+      }),
+    );
+
+    return NextResponse.json({
+      files: processedFiles,
+    });
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    return NextResponse.json(
+      { message: 'An error has occurred.' },
+      { status: 500 },
+    );
+  }
+}
--- a/src/app/api/videos/route.ts
+++ b/src/app/api/videos/route.ts
@@ -0,0 +1,83 @@
+import handleVideoSearch from '@/lib/chains/videoSearchAgent';
+import {
+  getCustomOpenaiApiKey,
+  getCustomOpenaiApiUrl,
+  getCustomOpenaiModelName,
+} from '@/lib/config';
+import { getAvailableChatModelProviders } from '@/lib/providers';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
+import { ChatOpenAI } from '@langchain/openai';
+
+interface ChatModel {
+  provider: string;
+  model: string;
+}
+
+interface VideoSearchBody {
+  query: string;
+  chatHistory: any[];
+  chatModel?: ChatModel;
+}
+
+export const POST = async (req: Request) => {
+  try {
+    const body: VideoSearchBody = await req.json();
+
+    const chatHistory = body.chatHistory
+      .map((msg: any) => {
+        if (msg.role === 'user') {
+          return new HumanMessage(msg.content);
+        } else if (msg.role === 'assistant') {
+          return new AIMessage(msg.content);
+        }
+      })
+      .filter((msg) => msg !== undefined) as BaseMessage[];
+
+    const chatModelProviders = await getAvailableChatModelProviders();
+
+    const chatModelProvider =
+      chatModelProviders[
+        body.chatModel?.provider || Object.keys(chatModelProviders)[0]
+      ];
+    const chatModel =
+      chatModelProvider[
+        body.chatModel?.model || Object.keys(chatModelProvider)[0]
+      ];
+
+    let llm: BaseChatModel | undefined;
+
+    if (body.chatModel?.provider === 'custom_openai') {
+      llm = new ChatOpenAI({
+        openAIApiKey: getCustomOpenaiApiKey(),
+        modelName: getCustomOpenaiModelName(),
+        temperature: 0.7,
+        configuration: {
+          baseURL: getCustomOpenaiApiUrl(),
+        },
+      }) as unknown as BaseChatModel;
+    } else if (chatModelProvider && chatModel) {
+      llm = chatModel.model;
+    }
+
+    if (!llm) {
+      return Response.json({ error: 'Invalid chat model' }, { status: 400 });
+    }
+
+    const videos = await handleVideoSearch(
+      {
+        chat_history: chatHistory,
+        query: body.query,
+      },
+      llm,
+    );
+
+    return Response.json({ videos }, { status: 200 });
+  } catch (err) {
+    console.error(`An error ocurred while searching videos: ${err}`);
+    return Response.json(
+      { message: 'An error ocurred while searching videos' },
+      { status: 500 },
+    );
+  }
+};
--- a/src/app/c/[chatId]/page.tsx
+++ b/src/app/c/[chatId]/page.tsx
@@ -0,0 +1,9 @@
+import ChatWindow from '@/components/ChatWindow';
+import React from 'react';
+
+const Page = ({ params }: { params: Promise<{ chatId: string }> }) => {
+  const { chatId } = React.use(params);
+  return <ChatWindow id={chatId} />;
+};
+
+export default Page;
--- a/src/app/discover/page.tsx
+++ b/src/app/discover/page.tsx
@@ -19,7 +19,7 @@ const Page = () => {
  useEffect(() => {
    const fetchData = async () => {
      try {
-        const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/discover`, {
+        const res = await fetch(`/api/discover`, {
          method: 'GET',
          headers: {
            'Content-Type': 'application/json',
--- a/src/app/favicon.ico
+++ b/src/app/favicon.ico
--- a/src/app/globals.css
+++ b/src/app/globals.css
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
--- a/src/app/library/layout.tsx
+++ b/src/app/library/layout.tsx
--- a/src/app/library/page.tsx
+++ b/src/app/library/page.tsx
@@ -21,7 +21,7 @@ const Page = () => {
    const fetchChats = async () => {
      setLoading(true);

-      const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/chats`, {
+      const res = await fetch(`/api/chats`, {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
--- a/src/app/settings/page.tsx
+++ b/src/app/settings/page.tsx
@@ -116,7 +116,7 @@ const Page = () => {
  useEffect(() => {
    const fetchConfig = async () => {
      setIsLoading(true);
-      const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/config`, {
+      const res = await fetch(`/api/config`, {
        headers: {
          'Content-Type': 'application/json',
        },
@@ -187,16 +187,13 @@ const Page = () => {
        [key]: value,
      } as SettingsType;

-      const response = await fetch(
-        `${process.env.NEXT_PUBLIC_API_URL}/config`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify(updatedConfig),
+      const response = await fetch(`/api/config`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
        },
-      );
+        body: JSON.stringify(updatedConfig),
+      });

      if (!response.ok) {
        throw new Error('Failed to update config');
@@ -208,7 +205,7 @@ const Page = () => {
        key.toLowerCase().includes('api') ||
        key.toLowerCase().includes('url')
      ) {
-        const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/config`, {
+        const res = await fetch(`/api/config`, {
          headers: {
            'Content-Type': 'application/json',
          },
@@ -223,11 +220,11 @@ const Page = () => {
        setChatModels(data.chatModelProviders || {});
        setEmbeddingModels(data.embeddingModelProviders || {});

-        const currentProvider = selectedChatModelProvider;
-        const newProviders = Object.keys(data.chatModelProviders || {});
+        const currentChatProvider = selectedChatModelProvider;
+        const newChatProviders = Object.keys(data.chatModelProviders || {});

-        if (!currentProvider && newProviders.length > 0) {
-          const firstProvider = newProviders[0];
+        if (!currentChatProvider && newChatProviders.length > 0) {
+          const firstProvider = newChatProviders[0];
          const firstModel = data.chatModelProviders[firstProvider]?.[0]?.name;

          if (firstModel) {
@@ -237,11 +234,11 @@ const Page = () => {
            localStorage.setItem('chatModel', firstModel);
          }
        } else if (
-          currentProvider &&
+          currentChatProvider &&
          (!data.chatModelProviders ||
-            !data.chatModelProviders[currentProvider] ||
-            !Array.isArray(data.chatModelProviders[currentProvider]) ||
-            data.chatModelProviders[currentProvider].length === 0)
+            !data.chatModelProviders[currentChatProvider] ||
+            !Array.isArray(data.chatModelProviders[currentChatProvider]) ||
+            data.chatModelProviders[currentChatProvider].length === 0)
        ) {
          const firstValidProvider = Object.entries(
            data.chatModelProviders || {},
@@ -267,6 +264,55 @@ const Page = () => {
          }
        }

+        const currentEmbeddingProvider = selectedEmbeddingModelProvider;
+        const newEmbeddingProviders = Object.keys(
+          data.embeddingModelProviders || {},
+        );
+
+        if (!currentEmbeddingProvider && newEmbeddingProviders.length > 0) {
+          const firstProvider = newEmbeddingProviders[0];
+          const firstModel =
+            data.embeddingModelProviders[firstProvider]?.[0]?.name;
+
+          if (firstModel) {
+            setSelectedEmbeddingModelProvider(firstProvider);
+            setSelectedEmbeddingModel(firstModel);
+            localStorage.setItem('embeddingModelProvider', firstProvider);
+            localStorage.setItem('embeddingModel', firstModel);
+          }
+        } else if (
+          currentEmbeddingProvider &&
+          (!data.embeddingModelProviders ||
+            !data.embeddingModelProviders[currentEmbeddingProvider] ||
+            !Array.isArray(
+              data.embeddingModelProviders[currentEmbeddingProvider],
+            ) ||
+            data.embeddingModelProviders[currentEmbeddingProvider].length === 0)
+        ) {
+          const firstValidProvider = Object.entries(
+            data.embeddingModelProviders || {},
+          ).find(
+            ([_, models]) => Array.isArray(models) && models.length > 0,
+          )?.[0];
+
+          if (firstValidProvider) {
+            setSelectedEmbeddingModelProvider(firstValidProvider);
+            setSelectedEmbeddingModel(
+              data.embeddingModelProviders[firstValidProvider][0].name,
+            );
+            localStorage.setItem('embeddingModelProvider', firstValidProvider);
+            localStorage.setItem(
+              'embeddingModel',
+              data.embeddingModelProviders[firstValidProvider][0].name,
+            );
+          } else {
+            setSelectedEmbeddingModelProvider(null);
+            setSelectedEmbeddingModel(null);
+            localStorage.removeItem('embeddingModelProvider');
+            localStorage.removeItem('embeddingModel');
+          }
+        }
+
        setConfig(data);
      }

@@ -278,6 +324,10 @@ const Page = () => {
        localStorage.setItem('chatModelProvider', value);
      } else if (key === 'chatModel') {
        localStorage.setItem('chatModel', value);
+      } else if (key === 'embeddingModelProvider') {
+        localStorage.setItem('embeddingModelProvider', value);
+      } else if (key === 'embeddingModel') {
+        localStorage.setItem('embeddingModel', value);
      }
    } catch (err) {
      console.error('Failed to save:', err);
@@ -436,7 +486,6 @@ const Page = () => {
                        const value = e.target.value;
                        setSelectedChatModelProvider(value);
                        saveConfig('chatModelProvider', value);
-                        // Auto-select first model of new provider
                        const firstModel =
                          config.chatModelProviders[value]?.[0]?.name;
                        if (firstModel) {
@@ -511,12 +560,16 @@ const Page = () => {
                      <Input
                        type="text"
                        placeholder="Model name"
-                        defaultValue={config.customOpenaiModelName}
-                        onChange={(e) =>
-                          setConfig({
-                            ...config,
+                        value={config.customOpenaiModelName}
+                        isSaving={savingStates['customOpenaiModelName']}
+                        onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
+                          setConfig((prev) => ({
+                            ...prev!,
                            customOpenaiModelName: e.target.value,
-                          })
+                          }));
+                        }}
+                        onSave={(value) =>
+                          saveConfig('customOpenaiModelName', value)
                        }
                      />
                    </div>
@@ -527,12 +580,16 @@ const Page = () => {
                      <Input
                        type="text"
                        placeholder="Custom OpenAI API Key"
-                        defaultValue={config.customOpenaiApiKey}
-                        onChange={(e) =>
-                          setConfig({
-                            ...config,
+                        value={config.customOpenaiApiKey}
+                        isSaving={savingStates['customOpenaiApiKey']}
+                        onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
+                          setConfig((prev) => ({
+                            ...prev!,
                            customOpenaiApiKey: e.target.value,
-                          })
+                          }));
+                        }}
+                        onSave={(value) =>
+                          saveConfig('customOpenaiApiKey', value)
                        }
                      />
                    </div>
@@ -543,17 +600,96 @@ const Page = () => {
                      <Input
                        type="text"
                        placeholder="Custom OpenAI Base URL"
-                        defaultValue={config.customOpenaiApiUrl}
-                        onChange={(e) =>
-                          setConfig({
-                            ...config,
+                        value={config.customOpenaiApiUrl}
+                        isSaving={savingStates['customOpenaiApiUrl']}
+                        onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
+                          setConfig((prev) => ({
+                            ...prev!,
                            customOpenaiApiUrl: e.target.value,
-                          })
+                          }));
+                        }}
+                        onSave={(value) =>
+                          saveConfig('customOpenaiApiUrl', value)
                        }
                      />
                    </div>
                  </div>
                )}
+
+              {config.embeddingModelProviders && (
+                <div className="flex flex-col space-y-4 mt-4 pt-4 border-t border-light-200 dark:border-dark-200">
+                  <div className="flex flex-col space-y-1">
+                    <p className="text-black/70 dark:text-white/70 text-sm">
+                      Embedding Model Provider
+                    </p>
+                    <Select
+                      value={selectedEmbeddingModelProvider ?? undefined}
+                      onChange={(e) => {
+                        const value = e.target.value;
+                        setSelectedEmbeddingModelProvider(value);
+                        saveConfig('embeddingModelProvider', value);
+                        const firstModel =
+                          config.embeddingModelProviders[value]?.[0]?.name;
+                        if (firstModel) {
+                          setSelectedEmbeddingModel(firstModel);
+                          saveConfig('embeddingModel', firstModel);
+                        }
+                      }}
+                      options={Object.keys(config.embeddingModelProviders).map(
+                        (provider) => ({
+                          value: provider,
+                          label:
+                            provider.charAt(0).toUpperCase() +
+                            provider.slice(1),
+                        }),
+                      )}
+                    />
+                  </div>
+
+                  {selectedEmbeddingModelProvider && (
+                    <div className="flex flex-col space-y-1">
+                      <p className="text-black/70 dark:text-white/70 text-sm">
+                        Embedding Model
+                      </p>
+                      <Select
+                        value={selectedEmbeddingModel ?? undefined}
+                        onChange={(e) => {
+                          const value = e.target.value;
+                          setSelectedEmbeddingModel(value);
+                          saveConfig('embeddingModel', value);
+                        }}
+                        options={(() => {
+                          const embeddingModelProvider =
+                            config.embeddingModelProviders[
+                              selectedEmbeddingModelProvider
+                            ];
+                          return embeddingModelProvider
+                            ? embeddingModelProvider.length > 0
+                              ? embeddingModelProvider.map((model) => ({
+                                  value: model.name,
+                                  label: model.displayName,
+                                }))
+                              : [
+                                  {
+                                    value: '',
+                                    label: 'No models available',
+                                    disabled: true,
+                                  },
+                                ]
+                            : [
+                                {
+                                  value: '',
+                                  label:
+                                    'Invalid provider, please check backend logs',
+                                  disabled: true,
+                                },
+                              ];
+                        })()}
+                      />
+                    </div>
+                  )}
+                </div>
+              )}
            </SettingsSection>

            <SettingsSection title="API Keys">
--- a/src/components/Chat.tsx
+++ b/src/components/Chat.tsx
@@ -48,11 +48,17 @@ const Chat = ({
  });

  useEffect(() => {
-    messageEnd.current?.scrollIntoView({ behavior: 'smooth' });
+    const scroll = () => {
+      messageEnd.current?.scrollIntoView({ behavior: 'smooth' });
+    };

    if (messages.length === 1) {
      document.title = `${messages[0].content.substring(0, 30)} - Perplexica`;
    }
+
+    if (messages[messages.length - 1]?.role == 'user') {
+      scroll();
+    }
  }, [messages]);

  return (
--- a/src/components/ChatWindow.tsx
+++ b/src/components/ChatWindow.tsx
@@ -29,280 +29,154 @@ export interface File {
  fileId: string;
 }

-const useSocket = (
-  url: string,
-  setIsWSReady: (ready: boolean) => void,
-  setError: (error: boolean) => void,
+interface ChatModelProvider {
+  name: string;
+  provider: string;
+}
+
+interface EmbeddingModelProvider {
+  name: string;
+  provider: string;
+}
+
+const checkConfig = async (
+  setChatModelProvider: (provider: ChatModelProvider) => void,
+  setEmbeddingModelProvider: (provider: EmbeddingModelProvider) => void,
+  setIsConfigReady: (ready: boolean) => void,
+  setHasError: (hasError: boolean) => void,
 ) => {
-  const wsRef = useRef<WebSocket | null>(null);
-  const reconnectTimeoutRef = useRef<NodeJS.Timeout>();
-  const retryCountRef = useRef(0);
-  const isCleaningUpRef = useRef(false);
-  const MAX_RETRIES = 3;
-  const INITIAL_BACKOFF = 1000; // 1 second
-  const isConnectionErrorRef = useRef(false);
+  try {
+    let chatModel = localStorage.getItem('chatModel');
+    let chatModelProvider = localStorage.getItem('chatModelProvider');
+    let embeddingModel = localStorage.getItem('embeddingModel');
+    let embeddingModelProvider = localStorage.getItem('embeddingModelProvider');

-  const getBackoffDelay = (retryCount: number) => {
-    return Math.min(INITIAL_BACKOFF * Math.pow(2, retryCount), 10000); // Cap at 10 seconds
-  };
+    const autoImageSearch = localStorage.getItem('autoImageSearch');
+    const autoVideoSearch = localStorage.getItem('autoVideoSearch');

-  useEffect(() => {
-    const connectWs = async () => {
-      if (wsRef.current?.readyState === WebSocket.OPEN) {
-        wsRef.current.close();
+    if (!autoImageSearch) {
+      localStorage.setItem('autoImageSearch', 'true');
+    }
+
+    if (!autoVideoSearch) {
+      localStorage.setItem('autoVideoSearch', 'false');
+    }
+
+    const providers = await fetch(`/api/models`, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    }).then(async (res) => {
+      if (!res.ok)
+        throw new Error(
+          `Failed to fetch models: ${res.status} ${res.statusText}`,
+        );
+      return res.json();
+    });
+
+    if (
+      !chatModel ||
+      !chatModelProvider ||
+      !embeddingModel ||
+      !embeddingModelProvider
+    ) {
+      if (!chatModel || !chatModelProvider) {
+        const chatModelProviders = providers.chatModelProviders;
+
+        chatModelProvider =
+          chatModelProvider || Object.keys(chatModelProviders)[0];
+
+        chatModel = Object.keys(chatModelProviders[chatModelProvider])[0];
+
+        if (!chatModelProviders || Object.keys(chatModelProviders).length === 0)
+          return toast.error('No chat models available');
      }

-      try {
-        let chatModel = localStorage.getItem('chatModel');
-        let chatModelProvider = localStorage.getItem('chatModelProvider');
-        let embeddingModel = localStorage.getItem('embeddingModel');
-        let embeddingModelProvider = localStorage.getItem(
-          'embeddingModelProvider',
-        );
-
-        const autoImageSearch = localStorage.getItem('autoImageSearch');
-        const autoVideoSearch = localStorage.getItem('autoVideoSearch');
-
-        if (!autoImageSearch) {
-          localStorage.setItem('autoImageSearch', 'true');
-        }
-
-        if (!autoVideoSearch) {
-          localStorage.setItem('autoVideoSearch', 'false');
-        }
-
-        const providers = await fetch(
-          `${process.env.NEXT_PUBLIC_API_URL}/models`,
-          {
-            headers: {
-              'Content-Type': 'application/json',
-            },
-          },
-        ).then(async (res) => {
-          if (!res.ok)
-            throw new Error(
-              `Failed to fetch models: ${res.status} ${res.statusText}`,
-            );
-          return res.json();
-        });
+      if (!embeddingModel || !embeddingModelProvider) {
+        const embeddingModelProviders = providers.embeddingModelProviders;

        if (
-          !chatModel ||
-          !chatModelProvider ||
-          !embeddingModel ||
-          !embeddingModelProvider
-        ) {
-          if (!chatModel || !chatModelProvider) {
-            const chatModelProviders = providers.chatModelProviders;
+          !embeddingModelProviders ||
+          Object.keys(embeddingModelProviders).length === 0
+        )
+          return toast.error('No embedding models available');

-            chatModelProvider =
-              chatModelProvider || Object.keys(chatModelProviders)[0];
-
-            chatModel = Object.keys(chatModelProviders[chatModelProvider])[0];
-
-            if (
-              !chatModelProviders ||
-              Object.keys(chatModelProviders).length === 0
-            )
-              return toast.error('No chat models available');
-          }
-
-          if (!embeddingModel || !embeddingModelProvider) {
-            const embeddingModelProviders = providers.embeddingModelProviders;
-
-            if (
-              !embeddingModelProviders ||
-              Object.keys(embeddingModelProviders).length === 0
-            )
-              return toast.error('No embedding models available');
-
-            embeddingModelProvider = Object.keys(embeddingModelProviders)[0];
-            embeddingModel = Object.keys(
-              embeddingModelProviders[embeddingModelProvider],
-            )[0];
-          }
-
-          localStorage.setItem('chatModel', chatModel!);
-          localStorage.setItem('chatModelProvider', chatModelProvider);
-          localStorage.setItem('embeddingModel', embeddingModel!);
-          localStorage.setItem(
-            'embeddingModelProvider',
-            embeddingModelProvider,
-          );
-        } else {
-          const chatModelProviders = providers.chatModelProviders;
-          const embeddingModelProviders = providers.embeddingModelProviders;
-
-          if (
-            Object.keys(chatModelProviders).length > 0 &&
-            !chatModelProviders[chatModelProvider]
-          ) {
-            const chatModelProvidersKeys = Object.keys(chatModelProviders);
-            chatModelProvider =
-              chatModelProvidersKeys.find(
-                (key) => Object.keys(chatModelProviders[key]).length > 0,
-              ) || chatModelProvidersKeys[0];
-
-            localStorage.setItem('chatModelProvider', chatModelProvider);
-          }
-
-          if (
-            chatModelProvider &&
-            !chatModelProviders[chatModelProvider][chatModel]
-          ) {
-            chatModel = Object.keys(
-              chatModelProviders[
-                Object.keys(chatModelProviders[chatModelProvider]).length > 0
-                  ? chatModelProvider
-                  : Object.keys(chatModelProviders)[0]
-              ],
-            )[0];
-            localStorage.setItem('chatModel', chatModel);
-          }
-
-          if (
-            Object.keys(embeddingModelProviders).length > 0 &&
-            !embeddingModelProviders[embeddingModelProvider]
-          ) {
-            embeddingModelProvider = Object.keys(embeddingModelProviders)[0];
-            localStorage.setItem(
-              'embeddingModelProvider',
-              embeddingModelProvider,
-            );
-          }
-
-          if (
-            embeddingModelProvider &&
-            !embeddingModelProviders[embeddingModelProvider][embeddingModel]
-          ) {
-            embeddingModel = Object.keys(
-              embeddingModelProviders[embeddingModelProvider],
-            )[0];
-            localStorage.setItem('embeddingModel', embeddingModel);
-          }
-        }
-
-        const wsURL = new URL(url);
-        const searchParams = new URLSearchParams({});
-
-        searchParams.append('chatModel', chatModel!);
-        searchParams.append('chatModelProvider', chatModelProvider);
-
-        if (chatModelProvider === 'custom_openai') {
-          searchParams.append(
-            'openAIApiKey',
-            localStorage.getItem('openAIApiKey')!,
-          );
-          searchParams.append(
-            'openAIBaseURL',
-            localStorage.getItem('openAIBaseURL')!,
-          );
-        }
-
-        searchParams.append('embeddingModel', embeddingModel!);
-        searchParams.append('embeddingModelProvider', embeddingModelProvider);
-
-        wsURL.search = searchParams.toString();
-
-        const ws = new WebSocket(wsURL.toString());
-        wsRef.current = ws;
-
-        const timeoutId = setTimeout(() => {
-          if (ws.readyState !== 1) {
-            toast.error(
-              'Failed to connect to the server. Please try again later.',
-            );
-          }
-        }, 10000);
-
-        ws.addEventListener('message', (e) => {
-          const data = JSON.parse(e.data);
-          if (data.type === 'signal' && data.data === 'open') {
-            const interval = setInterval(() => {
-              if (ws.readyState === 1) {
-                setIsWSReady(true);
-                setError(false);
-                if (retryCountRef.current > 0) {
-                  toast.success('Connection restored.');
-                }
-                retryCountRef.current = 0;
-                clearInterval(interval);
-              }
-            }, 5);
-            clearTimeout(timeoutId);
-            console.debug(new Date(), 'ws:connected');
-          }
-          if (data.type === 'error') {
-            isConnectionErrorRef.current = true;
-            setError(true);
-            toast.error(data.data);
-          }
-        });
-
-        ws.onerror = () => {
-          clearTimeout(timeoutId);
-          setIsWSReady(false);
-          toast.error('WebSocket connection error.');
-        };
-
-        ws.onclose = () => {
-          clearTimeout(timeoutId);
-          setIsWSReady(false);
-          console.debug(new Date(), 'ws:disconnected');
-          if (!isCleaningUpRef.current && !isConnectionErrorRef.current) {
-            toast.error('Connection lost. Attempting to reconnect...');
-            attemptReconnect();
-          }
-        };
-      } catch (error) {
-        console.debug(new Date(), 'ws:error', error);
-        setIsWSReady(false);
-        attemptReconnect();
-      }
-    };
-
-    const attemptReconnect = () => {
-      retryCountRef.current += 1;
-
-      if (retryCountRef.current > MAX_RETRIES) {
-        console.debug(new Date(), 'ws:max_retries');
-        setError(true);
-        toast.error(
-          'Unable to connect to server after multiple attempts. Please refresh the page to try again.',
-        );
-        return;
+        embeddingModelProvider = Object.keys(embeddingModelProviders)[0];
+        embeddingModel = Object.keys(
+          embeddingModelProviders[embeddingModelProvider],
+        )[0];
      }

-      const backoffDelay = getBackoffDelay(retryCountRef.current);
-      console.debug(
-        new Date(),
-        `ws:retry attempt=${retryCountRef.current}/${MAX_RETRIES} delay=${backoffDelay}ms`,
-      );
+      localStorage.setItem('chatModel', chatModel!);
+      localStorage.setItem('chatModelProvider', chatModelProvider);
+      localStorage.setItem('embeddingModel', embeddingModel!);
+      localStorage.setItem('embeddingModelProvider', embeddingModelProvider);
+    } else {
+      const chatModelProviders = providers.chatModelProviders;
+      const embeddingModelProviders = providers.embeddingModelProviders;

-      if (reconnectTimeoutRef.current) {
-        clearTimeout(reconnectTimeoutRef.current);
+      if (
+        Object.keys(chatModelProviders).length > 0 &&
+        !chatModelProviders[chatModelProvider]
+      ) {
+        const chatModelProvidersKeys = Object.keys(chatModelProviders);
+        chatModelProvider =
+          chatModelProvidersKeys.find(
+            (key) => Object.keys(chatModelProviders[key]).length > 0,
+          ) || chatModelProvidersKeys[0];
+
+        localStorage.setItem('chatModelProvider', chatModelProvider);
      }

-      reconnectTimeoutRef.current = setTimeout(() => {
-        connectWs();
-      }, backoffDelay);
-    };
-
-    connectWs();
-
-    return () => {
-      if (reconnectTimeoutRef.current) {
-        clearTimeout(reconnectTimeoutRef.current);
+      if (
+        chatModelProvider &&
+        !chatModelProviders[chatModelProvider][chatModel]
+      ) {
+        chatModel = Object.keys(
+          chatModelProviders[
+            Object.keys(chatModelProviders[chatModelProvider]).length > 0
+              ? chatModelProvider
+              : Object.keys(chatModelProviders)[0]
+          ],
+        )[0];
+        localStorage.setItem('chatModel', chatModel);
      }
-      if (wsRef.current?.readyState === WebSocket.OPEN) {
-        wsRef.current.close();
-        isCleaningUpRef.current = true;
-        console.debug(new Date(), 'ws:cleanup');
-      }
-    };
-  }, [url, setIsWSReady, setError]);

-  return wsRef.current;
+      if (
+        Object.keys(embeddingModelProviders).length > 0 &&
+        !embeddingModelProviders[embeddingModelProvider]
+      ) {
+        embeddingModelProvider = Object.keys(embeddingModelProviders)[0];
+        localStorage.setItem('embeddingModelProvider', embeddingModelProvider);
+      }
+
+      if (
+        embeddingModelProvider &&
+        !embeddingModelProviders[embeddingModelProvider][embeddingModel]
+      ) {
+        embeddingModel = Object.keys(
+          embeddingModelProviders[embeddingModelProvider],
+        )[0];
+        localStorage.setItem('embeddingModel', embeddingModel);
+      }
+    }
+
+    setChatModelProvider({
+      name: chatModel!,
+      provider: chatModelProvider,
+    });
+
+    setEmbeddingModelProvider({
+      name: embeddingModel!,
+      provider: embeddingModelProvider,
+    });
+
+    setIsConfigReady(true);
+  } catch (err) {
+    console.error('An error occurred while checking the configuration:', err);
+    setIsConfigReady(false);
+    setHasError(true);
+  }
 };

 const loadMessages = async (
@@ -315,15 +189,12 @@ const loadMessages = async (
  setFiles: (files: File[]) => void,
  setFileIds: (fileIds: string[]) => void,
 ) => {
-  const res = await fetch(
-    `${process.env.NEXT_PUBLIC_API_URL}/chats/${chatId}`,
-    {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-      },
+  const res = await fetch(`/api/chats/${chatId}`, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
    },
-  );
+  });

  if (res.status === 404) {
    setNotFound(true);
@@ -373,15 +244,32 @@ const ChatWindow = ({ id }: { id?: string }) => {
  const [chatId, setChatId] = useState<string | undefined>(id);
  const [newChatCreated, setNewChatCreated] = useState(false);

+  const [chatModelProvider, setChatModelProvider] = useState<ChatModelProvider>(
+    {
+      name: '',
+      provider: '',
+    },
+  );
+
+  const [embeddingModelProvider, setEmbeddingModelProvider] =
+    useState<EmbeddingModelProvider>({
+      name: '',
+      provider: '',
+    });
+
+  const [isConfigReady, setIsConfigReady] = useState(false);
  const [hasError, setHasError] = useState(false);
  const [isReady, setIsReady] = useState(false);

-  const [isWSReady, setIsWSReady] = useState(false);
-  const ws = useSocket(
-    process.env.NEXT_PUBLIC_WS_URL!,
-    setIsWSReady,
-    setHasError,
-  );
+  useEffect(() => {
+    checkConfig(
+      setChatModelProvider,
+      setEmbeddingModelProvider,
+      setIsConfigReady,
+      setHasError,
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);

  const [loading, setLoading] = useState(false);
  const [messageAppeared, setMessageAppeared] = useState(false);
@@ -399,8 +287,6 @@ const ChatWindow = ({ id }: { id?: string }) => {

  const [notFound, setNotFound] = useState(false);

-  const [isSettingsOpen, setIsSettingsOpen] = useState(false);
-
  useEffect(() => {
    if (
      chatId &&
@@ -426,16 +312,6 @@ const ChatWindow = ({ id }: { id?: string }) => {
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

-  useEffect(() => {
-    return () => {
-      if (ws?.readyState === 1) {
-        ws.close();
-        console.debug(new Date(), 'ws:cleanup');
-      }
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
  const messagesRef = useRef<Message[]>([]);

  useEffect(() => {
@@ -443,18 +319,18 @@ const ChatWindow = ({ id }: { id?: string }) => {
  }, [messages]);

  useEffect(() => {
-    if (isMessagesLoaded && isWSReady) {
+    if (isMessagesLoaded && isConfigReady) {
      setIsReady(true);
      console.debug(new Date(), 'app:ready');
    } else {
      setIsReady(false);
    }
-  }, [isMessagesLoaded, isWSReady]);
+  }, [isMessagesLoaded, isConfigReady]);

  const sendMessage = async (message: string, messageId?: string) => {
    if (loading) return;
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
-      toast.error('Cannot send message while disconnected');
+    if (!isConfigReady) {
+      toast.error('Cannot send message before the configuration is ready');
      return;
    }

@@ -467,18 +343,27 @@ const ChatWindow = ({ id }: { id?: string }) => {

    messageId = messageId ?? crypto.randomBytes(7).toString('hex');

-    ws.send(
+    console.log(
      JSON.stringify({
-        type: 'message',
+        content: message,
        message: {
          messageId: messageId,
          chatId: chatId!,
          content: message,
        },
+        chatId: chatId!,
        files: fileIds,
        focusMode: focusMode,
        optimizationMode: optimizationMode,
-        history: [...chatHistory, ['human', message]],
+        history: chatHistory,
+        chatModel: {
+          name: chatModelProvider.name,
+          provider: chatModelProvider.provider,
+        },
+        embeddingModel: {
+          name: embeddingModelProvider.name,
+          provider: embeddingModelProvider.provider,
+        },
      }),
    );

@@ -493,9 +378,7 @@ const ChatWindow = ({ id }: { id?: string }) => {
      },
    ]);

-    const messageHandler = async (e: MessageEvent) => {
-      const data = JSON.parse(e.data);
-
+    const messageHandler = async (data: any) => {
      if (data.type === 'error') {
        toast.error(data.data);
        setLoading(false);
@@ -558,7 +441,6 @@ const ChatWindow = ({ id }: { id?: string }) => {
          ['assistant', recievedMessage],
        ]);

-        ws?.removeEventListener('message', messageHandler);
        setLoading(false);

        const lastMsg = messagesRef.current[messagesRef.current.length - 1];
@@ -584,16 +466,72 @@ const ChatWindow = ({ id }: { id?: string }) => {
        const autoVideoSearch = localStorage.getItem('autoVideoSearch');

        if (autoImageSearch === 'true') {
-          document.getElementById('search-images')?.click();
+          document
+            .getElementById(`search-images-${lastMsg.messageId}`)
+            ?.click();
        }

        if (autoVideoSearch === 'true') {
-          document.getElementById('search-videos')?.click();
+          document
+            .getElementById(`search-videos-${lastMsg.messageId}`)
+            ?.click();
        }
      }
    };

-    ws?.addEventListener('message', messageHandler);
+    const res = await fetch('/api/chat', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        content: message,
+        message: {
+          messageId: messageId,
+          chatId: chatId!,
+          content: message,
+        },
+        chatId: chatId!,
+        files: fileIds,
+        focusMode: focusMode,
+        optimizationMode: optimizationMode,
+        history: chatHistory,
+        chatModel: {
+          name: chatModelProvider.name,
+          provider: chatModelProvider.provider,
+        },
+        embeddingModel: {
+          name: embeddingModelProvider.name,
+          provider: embeddingModelProvider.provider,
+        },
+      }),
+    });
+
+    if (!res.body) throw new Error('No response body');
+
+    const reader = res.body?.getReader();
+    const decoder = new TextDecoder('utf-8');
+
+    let partialChunk = '';
+
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+
+      partialChunk += decoder.decode(value, { stream: true });
+
+      try {
+        const messages = partialChunk.split('\n');
+        for (const msg of messages) {
+          if (!msg.trim()) continue;
+          const json = JSON.parse(msg);
+          messageHandler(json);
+        }
+        partialChunk = '';
+      } catch (error) {
+        console.warn('Incomplete JSON, waiting for next chunk...');
+      }
+    }
  };

  const rewrite = (messageId: string) => {
@@ -614,11 +552,11 @@ const ChatWindow = ({ id }: { id?: string }) => {
  };

  useEffect(() => {
-    if (isReady && initialMessage && ws?.readyState === 1) {
+    if (isReady && initialMessage && isConfigReady) {
      sendMessage(initialMessage);
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [ws?.readyState, isReady, initialMessage, isWSReady]);
+  }, [isConfigReady, isReady, initialMessage]);

  if (hasError) {
    return (
--- a/src/components/DeleteChat.tsx
+++ b/src/components/DeleteChat.tsx
@@ -29,15 +29,12 @@ const DeleteChat = ({
  const handleDelete = async () => {
    setLoading(true);
    try {
-      const res = await fetch(
-        `${process.env.NEXT_PUBLIC_API_URL}/chats/${chatId}`,
-        {
-          method: 'DELETE',
-          headers: {
-            'Content-Type': 'application/json',
-          },
+      const res = await fetch(`/api/chats/${chatId}`, {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
        },
-      );
+      });

      if (res.status != 200) {
        throw new Error('Failed to delete chat');
--- a/src/components/EmptyChat.tsx
+++ b/src/components/EmptyChat.tsx
--- a/src/components/EmptyChatMessageInput.tsx
+++ b/src/components/EmptyChatMessageInput.tsx
--- a/src/components/Layout.tsx
+++ b/src/components/Layout.tsx
--- a/src/components/MessageActions/Copy.tsx
+++ b/src/components/MessageActions/Copy.tsx
--- a/src/components/MessageActions/Rewrite.tsx
+++ b/src/components/MessageActions/Rewrite.tsx
--- a/src/components/MessageBox.tsx
+++ b/src/components/MessageBox.tsx
@@ -68,7 +68,13 @@ const MessageBox = ({
  return (
    <div>
      {message.role === 'user' && (
-        <div className={cn('w-full', messageIndex === 0 ? 'pt-16' : 'pt-8')}>
+        <div
+          className={cn(
+            'w-full',
+            messageIndex === 0 ? 'pt-16' : 'pt-8',
+            'break-words',
+          )}
+        >
          <h2 className="text-black dark:text-white font-medium text-3xl lg:w-9/12">
            {message.content}
          </h2>
@@ -187,10 +193,12 @@ const MessageBox = ({
            <SearchImages
              query={history[messageIndex - 1].content}
              chatHistory={history.slice(0, messageIndex - 1)}
+              messageId={message.messageId}
            />
            <SearchVideos
              chatHistory={history.slice(0, messageIndex - 1)}
              query={history[messageIndex - 1].content}
+              messageId={message.messageId}
            />
          </div>
        </div>
--- a/src/components/MessageBoxLoading.tsx
+++ b/src/components/MessageBoxLoading.tsx
--- a/src/components/MessageInput.tsx
+++ b/src/components/MessageInput.tsx
--- a/src/components/MessageInputActions/Attach.tsx
+++ b/src/components/MessageInputActions/Attach.tsx
@@ -41,7 +41,7 @@ const Attach = ({
    data.append('embedding_model_provider', embeddingModelProvider!);
    data.append('embedding_model', embeddingModel!);

-    const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/uploads`, {
+    const res = await fetch(`/api/uploads`, {
      method: 'POST',
      body: data,
    });
@@ -110,7 +110,7 @@ const Attach = ({
                <button
                  type="button"
                  onClick={() => fileInputRef.current.click()}
-                  className="flex flex-row items-center space-x-1 text-white/70 hover:text-white transition duration-200"
+                  className="flex flex-row items-center space-x-1 text-black/70 dark:text-white/70 hover:text-black hover:dark:text-white transition duration-200"
                >
                  <input
                    type="file"
@@ -128,7 +128,7 @@ const Attach = ({
                    setFiles([]);
                    setFileIds([]);
                  }}
-                  className="flex flex-row items-center space-x-1 text-white/70 hover:text-white transition duration-200"
+                  className="flex flex-row items-center space-x-1 text-black/70 dark:text-white/70 hover:text-black hover:dark:text-white transition duration-200"
                >
                  <Trash size={14} />
                  <p className="text-xs">Clear</p>
@@ -145,7 +145,7 @@ const Attach = ({
                  <div className="bg-dark-100 flex items-center justify-center w-10 h-10 rounded-md">
                    <File size={16} className="text-white/70" />
                  </div>
-                  <p className="text-white/70 text-sm">
+                  <p className="text-black/70 dark:text-white/70 text-sm">
                    {file.fileName.length > 25
                      ? file.fileName.replace(/\.\w+$/, '').substring(0, 25) +
                        '...' +
--- a/src/components/MessageInputActions/AttachSmall.tsx
+++ b/src/components/MessageInputActions/AttachSmall.tsx
@@ -39,7 +39,7 @@ const AttachSmall = ({
    data.append('embedding_model_provider', embeddingModelProvider!);
    data.append('embedding_model', embeddingModel!);

-    const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/uploads`, {
+    const res = await fetch(`/api/uploads`, {
      method: 'POST',
      body: data,
    });
@@ -82,7 +82,7 @@ const AttachSmall = ({
                <button
                  type="button"
                  onClick={() => fileInputRef.current.click()}
-                  className="flex flex-row items-center space-x-1 text-white/70 hover:text-white transition duration-200"
+                  className="flex flex-row items-center space-x-1 text-black/70 dark:text-white/70 hover:text-black hover:dark:text-white transition duration-200"
                >
                  <input
                    type="file"
@@ -100,7 +100,7 @@ const AttachSmall = ({
                    setFiles([]);
                    setFileIds([]);
                  }}
-                  className="flex flex-row items-center space-x-1 text-white/70 hover:text-white transition duration-200"
+                  className="flex flex-row items-center space-x-1 text-black/70 dark:text-white/70 hover:text-black hover:dark:text-white transition duration-200"
                >
                  <Trash size={14} />
                  <p className="text-xs">Clear</p>
@@ -117,7 +117,7 @@ const AttachSmall = ({
                  <div className="bg-dark-100 flex items-center justify-center w-10 h-10 rounded-md">
                    <File size={16} className="text-white/70" />
                  </div>
-                  <p className="text-white/70 text-sm">
+                  <p className="text-black/70 dark:text-white/70 text-sm">
                    {file.fileName.length > 25
                      ? file.fileName.replace(/\.\w+$/, '').substring(0, 25) +
                        '...' +
--- a/src/components/MessageInputActions/Copilot.tsx
+++ b/src/components/MessageInputActions/Copilot.tsx
--- a/src/components/MessageInputActions/Focus.tsx
+++ b/src/components/MessageInputActions/Focus.tsx
@@ -45,25 +45,13 @@ const focusModes = [
    key: 'youtubeSearch',
    title: 'Youtube',
    description: 'Search and watch videos',
-    icon: (
-      <SiYoutube
-        className="h-5 w-auto mr-0.5"
-        onPointerEnterCapture={undefined}
-        onPointerLeaveCapture={undefined}
-      />
-    ),
+    icon: <SiYoutube className="h-5 w-auto mr-0.5" />,
  },
  {
    key: 'redditSearch',
    title: 'Reddit',
    description: 'Search for discussions and opinions',
-    icon: (
-      <SiReddit
-        className="h-5 w-auto mr-0.5"
-        onPointerEnterCapture={undefined}
-        onPointerLeaveCapture={undefined}
-      />
-    ),
+    icon: <SiReddit className="h-5 w-auto mr-0.5" />,
  },
 ];

--- a/src/components/MessageInputActions/Optimization.tsx
+++ b/src/components/MessageInputActions/Optimization.tsx
--- a/src/components/MessageSources.tsx
+++ b/src/components/MessageSources.tsx
@@ -69,11 +69,15 @@ const MessageSources = ({ sources }: { sources: Document[] }) => {
          <div className="flex flex-row items-center space-x-1">
            {sources.slice(3, 6).map((source, i) => {
              return source.metadata.url === 'File' ? (
-                <div className="bg-dark-200 hover:bg-dark-100 transition duration-200 flex items-center justify-center w-6 h-6 rounded-full">
+                <div
+                  key={i}
+                  className="bg-dark-200 hover:bg-dark-100 transition duration-200 flex items-center justify-center w-6 h-6 rounded-full"
+                >
                  <File size={12} className="text-white/70" />
                </div>
              ) : (
                <img
+                  key={i}
                  src={`https://s2.googleusercontent.com/s2/favicons?domain_url=${source.metadata.url}`}
                  width={16}
                  height={16}
--- a/src/components/Navbar.tsx
+++ b/src/components/Navbar.tsx
--- a/src/components/SearchImages.tsx
+++ b/src/components/SearchImages.tsx
@@ -14,9 +14,11 @@ type Image = {
 const SearchImages = ({
  query,
  chatHistory,
+  messageId,
 }: {
  query: string;
  chatHistory: Message[];
+  messageId: string;
 }) => {
  const [images, setImages] = useState<Image[] | null>(null);
  const [loading, setLoading] = useState(false);
@@ -27,7 +29,7 @@ const SearchImages = ({
    <>
      {!loading && images === null && (
        <button
-          id="search-images"
+          id={`search-images-${messageId}`}
          onClick={async () => {
            setLoading(true);

@@ -37,27 +39,24 @@ const SearchImages = ({
            const customOpenAIBaseURL = localStorage.getItem('openAIBaseURL');
            const customOpenAIKey = localStorage.getItem('openAIApiKey');

-            const res = await fetch(
-              `${process.env.NEXT_PUBLIC_API_URL}/images`,
-              {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                  query: query,
-                  chatHistory: chatHistory,
-                  chatModel: {
-                    provider: chatModelProvider,
-                    model: chatModel,
-                    ...(chatModelProvider === 'custom_openai' && {
-                      customOpenAIBaseURL: customOpenAIBaseURL,
-                      customOpenAIKey: customOpenAIKey,
-                    }),
-                  },
-                }),
+            const res = await fetch(`/api/images`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
              },
-            );
+              body: JSON.stringify({
+                query: query,
+                chatHistory: chatHistory,
+                chatModel: {
+                  provider: chatModelProvider,
+                  model: chatModel,
+                  ...(chatModelProvider === 'custom_openai' && {
+                    customOpenAIBaseURL: customOpenAIBaseURL,
+                    customOpenAIKey: customOpenAIKey,
+                  }),
+                },
+              }),
+            });

            const data = await res.json();

--- a/src/components/SearchVideos.tsx
+++ b/src/components/SearchVideos.tsx
@@ -27,9 +27,11 @@ declare module 'yet-another-react-lightbox' {
 const Searchvideos = ({
  query,
  chatHistory,
+  messageId,
 }: {
  query: string;
  chatHistory: Message[];
+  messageId: string;
 }) => {
  const [videos, setVideos] = useState<Video[] | null>(null);
  const [loading, setLoading] = useState(false);
@@ -42,7 +44,7 @@ const Searchvideos = ({
    <>
      {!loading && videos === null && (
        <button
-          id="search-videos"
+          id={`search-videos-${messageId}`}
          onClick={async () => {
            setLoading(true);

@@ -52,27 +54,24 @@ const Searchvideos = ({
            const customOpenAIBaseURL = localStorage.getItem('openAIBaseURL');
            const customOpenAIKey = localStorage.getItem('openAIApiKey');

-            const res = await fetch(
-              `${process.env.NEXT_PUBLIC_API_URL}/videos`,
-              {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                  query: query,
-                  chatHistory: chatHistory,
-                  chatModel: {
-                    provider: chatModelProvider,
-                    model: chatModel,
-                    ...(chatModelProvider === 'custom_openai' && {
-                      customOpenAIBaseURL: customOpenAIBaseURL,
-                      customOpenAIKey: customOpenAIKey,
-                    }),
-                  },
-                }),
+            const res = await fetch(`/api/videos`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
              },
-            );
+              body: JSON.stringify({
+                query: query,
+                chatHistory: chatHistory,
+                chatModel: {
+                  provider: chatModelProvider,
+                  model: chatModel,
+                  ...(chatModelProvider === 'custom_openai' && {
+                    customOpenAIBaseURL: customOpenAIBaseURL,
+                    customOpenAIKey: customOpenAIKey,
+                  }),
+                },
+              }),
+            });

            const data = await res.json();

--- a/src/components/Sidebar.tsx
+++ b/src/components/Sidebar.tsx
--- a/src/components/theme/Provider.tsx
+++ b/src/components/theme/Provider.tsx
--- a/src/components/theme/Switcher.tsx
+++ b/src/components/theme/Switcher.tsx
--- a/src/components/ui/Select.tsx
+++ b/src/components/ui/Select.tsx
--- a/src/lib/actions.ts
+++ b/src/lib/actions.ts
@@ -7,7 +7,7 @@ export const getSuggestions = async (chatHisory: Message[]) => {
  const customOpenAIKey = localStorage.getItem('openAIApiKey');
  const customOpenAIBaseURL = localStorage.getItem('openAIBaseURL');

-  const res = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/suggestions`, {
+  const res = await fetch(`/api/suggestions`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
--- a/src/lib/chains/imageSearchAgent.ts
+++ b/src/lib/chains/imageSearchAgent.ts
@@ -7,7 +7,7 @@ import { PromptTemplate } from '@langchain/core/prompts';
 import formatChatHistoryAsString from '../utils/formatHistory';
 import { BaseMessage } from '@langchain/core/messages';
 import { StringOutputParser } from '@langchain/core/output_parsers';
-import { searchSearxng } from '../lib/searxng';
+import { searchSearxng } from '../searxng';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';

 const imageSearchChainPrompt = `
@@ -36,6 +36,12 @@ type ImageSearchChainInput = {
  query: string;
 };

+interface ImageSearchResult {
+  img_src: string;
+  url: string;
+  title: string;
+}
+
 const strParser = new StringOutputParser();

 const createImageSearchChain = (llm: BaseChatModel) => {
@@ -56,7 +62,7 @@ const createImageSearchChain = (llm: BaseChatModel) => {
        engines: ['bing images', 'google images'],
      });

-      const images = [];
+      const images: ImageSearchResult[] = [];

      res.results.forEach((result) => {
        if (result.img_src && result.url && result.title) {
--- a/src/lib/chains/suggestionGeneratorAgent.ts
+++ b/src/lib/chains/suggestionGeneratorAgent.ts
@@ -1,5 +1,5 @@
 import { RunnableSequence, RunnableMap } from '@langchain/core/runnables';
-import ListLineOutputParser from '../lib/outputParsers/listLineOutputParser';
+import ListLineOutputParser from '../outputParsers/listLineOutputParser';
 import { PromptTemplate } from '@langchain/core/prompts';
 import formatChatHistoryAsString from '../utils/formatHistory';
 import { BaseMessage } from '@langchain/core/messages';
--- a/src/lib/chains/videoSearchAgent.ts
+++ b/src/lib/chains/videoSearchAgent.ts
@@ -7,7 +7,7 @@ import { PromptTemplate } from '@langchain/core/prompts';
 import formatChatHistoryAsString from '../utils/formatHistory';
 import { BaseMessage } from '@langchain/core/messages';
 import { StringOutputParser } from '@langchain/core/output_parsers';
-import { searchSearxng } from '../lib/searxng';
+import { searchSearxng } from '../searxng';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';

 const VideoSearchChainPrompt = `
@@ -36,6 +36,13 @@ type VideoSearchChainInput = {
  query: string;
 };

+interface VideoSearchResult {
+  img_src: string;
+  url: string;
+  title: string;
+  iframe_src: string;
+}
+
 const strParser = new StringOutputParser();

 const createVideoSearchChain = (llm: BaseChatModel) => {
@@ -56,7 +63,7 @@ const createVideoSearchChain = (llm: BaseChatModel) => {
        engines: ['youtube'],
      });

-      const videos = [];
+      const videos: VideoSearchResult[] = [];

      res.results.forEach((result) => {
        if (
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -43,7 +43,7 @@ type RecursivePartial<T> = {

 const loadConfig = () =>
  toml.parse(
-    fs.readFileSync(path.join(__dirname, `../${configFileName}`), 'utf-8'),
+    fs.readFileSync(path.join(process.cwd(), `${configFileName}`), 'utf-8'),
  ) as any as Config;

 export const getPort = () => loadConfig().GENERAL.PORT;
@@ -62,7 +62,7 @@ export const getAnthropicApiKey = () => loadConfig().MODELS.ANTHROPIC.API_KEY;
 export const getGeminiApiKey = () => loadConfig().MODELS.GEMINI.API_KEY;

 export const getSearxngApiEndpoint = () =>
-  process.env.SEARXNG_API_URL || loadConfig().API_ENDPOINTS.SEARXNG;
+  loadConfig().API_ENDPOINTS.SEARXNG || process.env.SEARXNG_API_URL;

 export const getOllamaApiEndpoint = () => loadConfig().MODELS.OLLAMA.API_URL;

@@ -109,9 +109,8 @@ const mergeConfigs = (current: any, update: any): any => {
 export const updateConfig = (config: RecursivePartial<Config>) => {
  const currentConfig = loadConfig();
  const mergedConfig = mergeConfigs(currentConfig, config);
-
  fs.writeFileSync(
-    path.join(__dirname, `../${configFileName}`),
+    path.join(path.join(process.cwd(), `${configFileName}`)),
    toml.stringify(mergedConfig),
  );
 };
--- a/src/lib/db/index.ts
+++ b/src/lib/db/index.ts
@@ -1,8 +1,9 @@
 import { drizzle } from 'drizzle-orm/better-sqlite3';
 import Database from 'better-sqlite3';
 import * as schema from './schema';
+import path from 'path';

-const sqlite = new Database('data/db.sqlite');
+const sqlite = new Database(path.join(process.cwd(), 'data/db.sqlite'));
 const db = drizzle(sqlite, {
  schema: schema,
 });
--- a/src/lib/db/schema.ts
+++ b/src/lib/db/schema.ts
--- a/src/lib/huggingfaceTransformer.ts
+++ b/src/lib/huggingfaceTransformer.ts
@@ -1,82 +0,0 @@
-import { Embeddings, type EmbeddingsParams } from '@langchain/core/embeddings';
-import { chunkArray } from '@langchain/core/utils/chunk_array';
-
-export interface HuggingFaceTransformersEmbeddingsParams
-  extends EmbeddingsParams {
-  modelName: string;
-
-  model: string;
-
-  timeout?: number;
-
-  batchSize?: number;
-
-  stripNewLines?: boolean;
-}
-
-export class HuggingFaceTransformersEmbeddings
-  extends Embeddings
-  implements HuggingFaceTransformersEmbeddingsParams
-{
-  modelName = 'Xenova/all-MiniLM-L6-v2';
-
-  model = 'Xenova/all-MiniLM-L6-v2';
-
-  batchSize = 512;
-
-  stripNewLines = true;
-
-  timeout?: number;
-
-  private pipelinePromise: Promise<any>;
-
-  constructor(fields?: Partial<HuggingFaceTransformersEmbeddingsParams>) {
-    super(fields ?? {});
-
-    this.modelName = fields?.model ?? fields?.modelName ?? this.model;
-    this.model = this.modelName;
-    this.stripNewLines = fields?.stripNewLines ?? this.stripNewLines;
-    this.timeout = fields?.timeout;
-  }
-
-  async embedDocuments(texts: string[]): Promise<number[][]> {
-    const batches = chunkArray(
-      this.stripNewLines ? texts.map((t) => t.replace(/\n/g, ' ')) : texts,
-      this.batchSize,
-    );
-
-    const batchRequests = batches.map((batch) => this.runEmbedding(batch));
-    const batchResponses = await Promise.all(batchRequests);
-    const embeddings: number[][] = [];
-
-    for (let i = 0; i < batchResponses.length; i += 1) {
-      const batchResponse = batchResponses[i];
-      for (let j = 0; j < batchResponse.length; j += 1) {
-        embeddings.push(batchResponse[j]);
-      }
-    }
-
-    return embeddings;
-  }
-
-  async embedQuery(text: string): Promise<number[]> {
-    const data = await this.runEmbedding([
-      this.stripNewLines ? text.replace(/\n/g, ' ') : text,
-    ]);
-    return data[0];
-  }
-
-  private async runEmbedding(texts: string[]) {
-    const { pipeline } = await import('@xenova/transformers');
-
-    const pipe = await (this.pipelinePromise ??= pipeline(
-      'feature-extraction',
-      this.model,
-    ));
-
-    return this.caller.call(async () => {
-      const output = await pipe(texts, { pooling: 'mean', normalize: true });
-      return output.tolist();
-    });
-  }
-}
--- a/src/lib/outputParsers/lineOutputParser.ts
+++ b/src/lib/outputParsers/lineOutputParser.ts
@@ -9,7 +9,7 @@ class LineOutputParser extends BaseOutputParser<string> {

  constructor(args?: LineOutputParserArgs) {
    super();
-    this.key = args.key ?? this.key;
+    this.key = args?.key ?? this.key;
  }

  static lc_name() {
--- a/src/lib/outputParsers/listLineOutputParser.ts
+++ b/src/lib/outputParsers/listLineOutputParser.ts
@@ -9,7 +9,7 @@ class LineListOutputParser extends BaseOutputParser<string[]> {

  constructor(args?: LineListOutputParserArgs) {
    super();
-    this.key = args.key ?? this.key;
+    this.key = args?.key ?? this.key;
  }

  static lc_name() {
--- a/src/lib/prompts/academicSearch.ts
+++ b/src/lib/prompts/academicSearch.ts
--- a/src/lib/prompts/index.ts
+++ b/src/lib/prompts/index.ts
--- a/src/lib/prompts/redditSearch.ts
+++ b/src/lib/prompts/redditSearch.ts
--- a/src/lib/prompts/webSearch.ts
+++ b/src/lib/prompts/webSearch.ts
--- a/src/lib/prompts/wolframAlpha.ts
+++ b/src/lib/prompts/wolframAlpha.ts
--- a/src/lib/prompts/writingAssistant.ts
+++ b/src/lib/prompts/writingAssistant.ts
--- a/src/lib/prompts/youtubeSearch.ts
+++ b/src/lib/prompts/youtubeSearch.ts
--- a/src/lib/providers/anthropic.ts
+++ b/src/lib/providers/anthropic.ts
@@ -1,6 +1,38 @@
-import { ChatAnthropic } from '@langchain/anthropic';
-import { getAnthropicApiKey } from '../../config';
-import logger from '../../utils/logger';
+import { ChatOpenAI } from '@langchain/openai';
+import { ChatModel } from '.';
+import { getAnthropicApiKey } from '../config';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+const anthropicChatModels: Record<string, string>[] = [
+  {
+    displayName: 'Claude 3.7 Sonnet',
+    key: 'claude-3-7-sonnet-20250219',
+  },
+  {
+    displayName: 'Claude 3.5 Haiku',
+    key: 'claude-3-5-haiku-20241022',
+  },
+  {
+    displayName: 'Claude 3.5 Sonnet v2',
+    key: 'claude-3-5-sonnet-20241022',
+  },
+  {
+    displayName: 'Claude 3.5 Sonnet',
+    key: 'claude-3-5-sonnet-20240620',
+  },
+  {
+    displayName: 'Claude 3 Opus',
+    key: 'claude-3-opus-20240229',
+  },
+  {
+    displayName: 'Claude 3 Sonnet',
+    key: 'claude-3-sonnet-20240229',
+  },
+  {
+    displayName: 'Claude 3 Haiku',
+    key: 'claude-3-haiku-20240307',
+  },
+];

 export const loadAnthropicChatModels = async () => {
  const anthropicApiKey = getAnthropicApiKey();
@@ -8,52 +40,25 @@ export const loadAnthropicChatModels = async () => {
  if (!anthropicApiKey) return {};

  try {
-    const chatModels = {
-      'claude-3-5-sonnet-20241022': {
-        displayName: 'Claude 3.5 Sonnet',
-        model: new ChatAnthropic({
+    const chatModels: Record<string, ChatModel> = {};
+
+    anthropicChatModels.forEach((model) => {
+      chatModels[model.key] = {
+        displayName: model.displayName,
+        model: new ChatOpenAI({
+          openAIApiKey: anthropicApiKey,
+          modelName: model.key,
          temperature: 0.7,
-          anthropicApiKey: anthropicApiKey,
-          model: 'claude-3-5-sonnet-20241022',
-        }),
-      },
-      'claude-3-5-haiku-20241022': {
-        displayName: 'Claude 3.5 Haiku',
-        model: new ChatAnthropic({
-          temperature: 0.7,
-          anthropicApiKey: anthropicApiKey,
-          model: 'claude-3-5-haiku-20241022',
-        }),
-      },
-      'claude-3-opus-20240229': {
-        displayName: 'Claude 3 Opus',
-        model: new ChatAnthropic({
-          temperature: 0.7,
-          anthropicApiKey: anthropicApiKey,
-          model: 'claude-3-opus-20240229',
-        }),
-      },
-      'claude-3-sonnet-20240229': {
-        displayName: 'Claude 3 Sonnet',
-        model: new ChatAnthropic({
-          temperature: 0.7,
-          anthropicApiKey: anthropicApiKey,
-          model: 'claude-3-sonnet-20240229',
-        }),
-      },
-      'claude-3-haiku-20240307': {
-        displayName: 'Claude 3 Haiku',
-        model: new ChatAnthropic({
-          temperature: 0.7,
-          anthropicApiKey: anthropicApiKey,
-          model: 'claude-3-haiku-20240307',
-        }),
-      },
-    };
+          configuration: {
+            baseURL: 'https://api.anthropic.com/v1/',
+          },
+        }) as unknown as BaseChatModel,
+      };
+    });

    return chatModels;
  } catch (err) {
-    logger.error(`Error loading Anthropic models: ${err}`);
+    console.error(`Error loading Anthropic models: ${err}`);
    return {};
  }
 };
--- a/src/lib/providers/gemini.ts
+++ b/src/lib/providers/gemini.ts
@@ -1,9 +1,42 @@
-import {
-  ChatGoogleGenerativeAI,
-  GoogleGenerativeAIEmbeddings,
-} from '@langchain/google-genai';
-import { getGeminiApiKey } from '../../config';
-import logger from '../../utils/logger';
+import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
+import { getGeminiApiKey } from '../config';
+import { ChatModel, EmbeddingModel } from '.';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { Embeddings } from '@langchain/core/embeddings';
+
+const geminiChatModels: Record<string, string>[] = [
+  {
+    displayName: 'Gemini 2.0 Flash',
+    key: 'gemini-2.0-flash',
+  },
+  {
+    displayName: 'Gemini 2.0 Flash-Lite',
+    key: 'gemini-2.0-flash-lite',
+  },
+  {
+    displayName: 'Gemini 2.0 Pro Experimental',
+    key: 'gemini-2.0-pro-exp-02-05',
+  },
+  {
+    displayName: 'Gemini 1.5 Flash',
+    key: 'gemini-1.5-flash',
+  },
+  {
+    displayName: 'Gemini 1.5 Flash-8B',
+    key: 'gemini-1.5-flash-8b',
+  },
+  {
+    displayName: 'Gemini 1.5 Pro',
+    key: 'gemini-1.5-pro',
+  },
+];
+
+const geminiEmbeddingModels: Record<string, string>[] = [
+  {
+    displayName: 'Gemini Embedding',
+    key: 'gemini-embedding-exp',
+  },
+];

 export const loadGeminiChatModels = async () => {
  const geminiApiKey = getGeminiApiKey();
@@ -11,75 +44,53 @@ export const loadGeminiChatModels = async () => {
  if (!geminiApiKey) return {};

  try {
-    const chatModels = {
-      'gemini-1.5-flash': {
-        displayName: 'Gemini 1.5 Flash',
-        model: new ChatGoogleGenerativeAI({
-          modelName: 'gemini-1.5-flash',
+    const chatModels: Record<string, ChatModel> = {};
+
+    geminiChatModels.forEach((model) => {
+      chatModels[model.key] = {
+        displayName: model.displayName,
+        model: new ChatOpenAI({
+          openAIApiKey: geminiApiKey,
+          modelName: model.key,
          temperature: 0.7,
-          apiKey: geminiApiKey,
-        }),
-      },
-      'gemini-1.5-flash-8b': {
-        displayName: 'Gemini 1.5 Flash 8B',
-        model: new ChatGoogleGenerativeAI({
-          modelName: 'gemini-1.5-flash-8b',
-          temperature: 0.7,
-          apiKey: geminiApiKey,
-        }),
-      },
-      'gemini-1.5-pro': {
-        displayName: 'Gemini 1.5 Pro',
-        model: new ChatGoogleGenerativeAI({
-          modelName: 'gemini-1.5-pro',
-          temperature: 0.7,
-          apiKey: geminiApiKey,
-        }),
-      },
-      'gemini-2.0-flash-exp': {
-        displayName: 'Gemini 2.0 Flash Exp',
-        model: new ChatGoogleGenerativeAI({
-          modelName: 'gemini-2.0-flash-exp',
-          temperature: 0.7,
-          apiKey: geminiApiKey,
-        }),
-      },
-      'gemini-2.0-flash-thinking-exp-01-21': {
-        displayName: 'Gemini 2.0 Flash Thinking Exp 01-21',
-        model: new ChatGoogleGenerativeAI({
-          modelName: 'gemini-2.0-flash-thinking-exp-01-21',
-          temperature: 0.7,
-          apiKey: geminiApiKey,
-        }),
-      },
-    };
+          configuration: {
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+          },
+        }) as unknown as BaseChatModel,
+      };
+    });

    return chatModels;
  } catch (err) {
-    logger.error(`Error loading Gemini models: ${err}`);
+    console.error(`Error loading Gemini models: ${err}`);
    return {};
  }
 };

-export const loadGeminiEmbeddingsModels = async () => {
+export const loadGeminiEmbeddingModels = async () => {
  const geminiApiKey = getGeminiApiKey();

  if (!geminiApiKey) return {};

  try {
-    const embeddingModels = {
-      'text-embedding-004': {
-        displayName: 'Text Embedding',
-        model: new GoogleGenerativeAIEmbeddings({
-          apiKey: geminiApiKey,
-          modelName: 'text-embedding-004',
-        }),
-      },
-    };
+    const embeddingModels: Record<string, EmbeddingModel> = {};
+
+    geminiEmbeddingModels.forEach((model) => {
+      embeddingModels[model.key] = {
+        displayName: model.displayName,
+        model: new OpenAIEmbeddings({
+          openAIApiKey: geminiApiKey,
+          modelName: model.key,
+          configuration: {
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+          },
+        }) as unknown as Embeddings,
+      };
+    });

    return embeddingModels;
  } catch (err) {
-    logger.error(`Error loading Gemini embeddings model: ${err}`);
+    console.error(`Error loading OpenAI embeddings models: ${err}`);
    return {};
  }
 };
--- a/src/lib/providers/groq.ts
+++ b/src/lib/providers/groq.ts
@@ -1,6 +1,82 @@
 import { ChatOpenAI } from '@langchain/openai';
-import { getGroqApiKey } from '../../config';
-import logger from '../../utils/logger';
+import { getGroqApiKey } from '../config';
+import { ChatModel } from '.';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+const groqChatModels: Record<string, string>[] = [
+  {
+    displayName: 'Gemma2 9B IT',
+    key: 'gemma2-9b-it',
+  },
+  {
+    displayName: 'Llama 3.3 70B Versatile',
+    key: 'llama-3.3-70b-versatile',
+  },
+  {
+    displayName: 'Llama 3.1 8B Instant',
+    key: 'llama-3.1-8b-instant',
+  },
+  {
+    displayName: 'Llama3 70B 8192',
+    key: 'llama3-70b-8192',
+  },
+  {
+    displayName: 'Llama3 8B 8192',
+    key: 'llama3-8b-8192',
+  },
+  {
+    displayName: 'Mixtral 8x7B 32768',
+    key: 'mixtral-8x7b-32768',
+  },
+  {
+    displayName: 'Qwen QWQ 32B (Preview)',
+    key: 'qwen-qwq-32b',
+  },
+  {
+    displayName: 'Mistral Saba 24B (Preview)',
+    key: 'mistral-saba-24b',
+  },
+  {
+    displayName: 'Qwen 2.5 Coder 32B (Preview)',
+    key: 'qwen-2.5-coder-32b',
+  },
+  {
+    displayName: 'Qwen 2.5 32B (Preview)',
+    key: 'qwen-2.5-32b',
+  },
+  {
+    displayName: 'DeepSeek R1 Distill Qwen 32B (Preview)',
+    key: 'deepseek-r1-distill-qwen-32b',
+  },
+  {
+    displayName: 'DeepSeek R1 Distill Llama 70B SpecDec (Preview)',
+    key: 'deepseek-r1-distill-llama-70b-specdec',
+  },
+  {
+    displayName: 'DeepSeek R1 Distill Llama 70B (Preview)',
+    key: 'deepseek-r1-distill-llama-70b',
+  },
+  {
+    displayName: 'Llama 3.3 70B SpecDec (Preview)',
+    key: 'llama-3.3-70b-specdec',
+  },
+  {
+    displayName: 'Llama 3.2 1B Preview (Preview)',
+    key: 'llama-3.2-1b-preview',
+  },
+  {
+    displayName: 'Llama 3.2 3B Preview (Preview)',
+    key: 'llama-3.2-3b-preview',
+  },
+  {
+    displayName: 'Llama 3.2 11B Vision Preview (Preview)',
+    key: 'llama-3.2-11b-vision-preview',
+  },
+  {
+    displayName: 'Llama 3.2 90B Vision Preview (Preview)',
+    key: 'llama-3.2-90b-vision-preview',
+  },
+];

 export const loadGroqChatModels = async () => {
  const groqApiKey = getGroqApiKey();
@@ -8,129 +84,25 @@ export const loadGroqChatModels = async () => {
  if (!groqApiKey) return {};

  try {
-    const chatModels = {
-      'llama-3.3-70b-versatile': {
-        displayName: 'Llama 3.3 70B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama-3.3-70b-versatile',
-            temperature: 0.7,
-          },
-          {
+    const chatModels: Record<string, ChatModel> = {};
+
+    groqChatModels.forEach((model) => {
+      chatModels[model.key] = {
+        displayName: model.displayName,
+        model: new ChatOpenAI({
+          openAIApiKey: groqApiKey,
+          modelName: model.key,
+          temperature: 0.7,
+          configuration: {
            baseURL: 'https://api.groq.com/openai/v1',
          },
-        ),
-      },
-      'llama-3.2-3b-preview': {
-        displayName: 'Llama 3.2 3B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama-3.2-3b-preview',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'llama-3.2-11b-vision-preview': {
-        displayName: 'Llama 3.2 11B Vision',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama-3.2-11b-vision-preview',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'llama-3.2-90b-vision-preview': {
-        displayName: 'Llama 3.2 90B Vision',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama-3.2-90b-vision-preview',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'llama-3.1-8b-instant': {
-        displayName: 'Llama 3.1 8B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama-3.1-8b-instant',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'llama3-8b-8192': {
-        displayName: 'LLaMA3 8B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama3-8b-8192',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'llama3-70b-8192': {
-        displayName: 'LLaMA3 70B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'llama3-70b-8192',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'mixtral-8x7b-32768': {
-        displayName: 'Mixtral 8x7B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'mixtral-8x7b-32768',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-      'gemma2-9b-it': {
-        displayName: 'Gemma2 9B',
-        model: new ChatOpenAI(
-          {
-            openAIApiKey: groqApiKey,
-            modelName: 'gemma2-9b-it',
-            temperature: 0.7,
-          },
-          {
-            baseURL: 'https://api.groq.com/openai/v1',
-          },
-        ),
-      },
-    };
+        }) as unknown as BaseChatModel,
+      };
+    });

    return chatModels;
  } catch (err) {
-    logger.error(`Error loading Groq models: ${err}`);
+    console.error(`Error loading Groq models: ${err}`);
    return {};
  }
 };
--- a/src/lib/providers/index.ts
+++ b/src/lib/providers/index.ts
@@ -1,33 +1,49 @@
-import { loadGroqChatModels } from './groq';
-import { loadOllamaChatModels, loadOllamaEmbeddingsModels } from './ollama';
-import { loadOpenAIChatModels, loadOpenAIEmbeddingsModels } from './openai';
-import { loadAnthropicChatModels } from './anthropic';
-import { loadTransformersEmbeddingsModels } from './transformers';
-import { loadGeminiChatModels, loadGeminiEmbeddingsModels } from './gemini';
+import { Embeddings } from '@langchain/core/embeddings';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { loadOpenAIChatModels, loadOpenAIEmbeddingModels } from './openai';
 import {
  getCustomOpenaiApiKey,
  getCustomOpenaiApiUrl,
  getCustomOpenaiModelName,
-} from '../../config';
+} from '../config';
 import { ChatOpenAI } from '@langchain/openai';
+import { loadOllamaChatModels, loadOllamaEmbeddingModels } from './ollama';
+import { loadGroqChatModels } from './groq';
+import { loadAnthropicChatModels } from './anthropic';
+import { loadGeminiChatModels, loadGeminiEmbeddingModels } from './gemini';

-const chatModelProviders = {
+export interface ChatModel {
+  displayName: string;
+  model: BaseChatModel;
+}
+
+export interface EmbeddingModel {
+  displayName: string;
+  model: Embeddings;
+}
+
+export const chatModelProviders: Record<
+  string,
+  () => Promise<Record<string, ChatModel>>
+> = {
  openai: loadOpenAIChatModels,
-  groq: loadGroqChatModels,
  ollama: loadOllamaChatModels,
+  groq: loadGroqChatModels,
  anthropic: loadAnthropicChatModels,
  gemini: loadGeminiChatModels,
 };

-const embeddingModelProviders = {
-  openai: loadOpenAIEmbeddingsModels,
-  local: loadTransformersEmbeddingsModels,
-  ollama: loadOllamaEmbeddingsModels,
-  gemini: loadGeminiEmbeddingsModels,
+export const embeddingModelProviders: Record<
+  string,
+  () => Promise<Record<string, EmbeddingModel>>
+> = {
+  openai: loadOpenAIEmbeddingModels,
+  ollama: loadOllamaEmbeddingModels,
+  gemini: loadGeminiEmbeddingModels,
 };

 export const getAvailableChatModelProviders = async () => {
-  const models = {};
+  const models: Record<string, Record<string, ChatModel>> = {};

  for (const provider in chatModelProviders) {
    const providerModels = await chatModelProviders[provider]();
@@ -52,7 +68,7 @@ export const getAvailableChatModelProviders = async () => {
              configuration: {
                baseURL: customOpenAiApiUrl,
              },
-            }),
+            }) as unknown as BaseChatModel,
          },
        }
      : {}),
@@ -62,7 +78,7 @@ export const getAvailableChatModelProviders = async () => {
 };

 export const getAvailableEmbeddingModelProviders = async () => {
-  const models = {};
+  const models: Record<string, Record<string, EmbeddingModel>> = {};

  for (const provider in embeddingModelProviders) {
    const providerModels = await embeddingModelProviders[provider]();
--- a/src/lib/providers/ollama.ts
+++ b/src/lib/providers/ollama.ts
@@ -1,74 +1,73 @@
-import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
-import { getKeepAlive, getOllamaApiEndpoint } from '../../config';
-import logger from '../../utils/logger';
-import { ChatOllama } from '@langchain/community/chat_models/ollama';
 import axios from 'axios';
+import { getKeepAlive, getOllamaApiEndpoint } from '../config';
+import { ChatModel, EmbeddingModel } from '.';
+import { ChatOllama } from '@langchain/community/chat_models/ollama';
+import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';

 export const loadOllamaChatModels = async () => {
-  const ollamaEndpoint = getOllamaApiEndpoint();
-  const keepAlive = getKeepAlive();
+  const ollamaApiEndpoint = getOllamaApiEndpoint();

-  if (!ollamaEndpoint) return {};
+  if (!ollamaApiEndpoint) return {};

  try {
-    const response = await axios.get(`${ollamaEndpoint}/api/tags`, {
+    const res = await axios.get(`${ollamaApiEndpoint}/api/tags`, {
      headers: {
        'Content-Type': 'application/json',
      },
    });

-    const { models: ollamaModels } = response.data;
+    const { models } = res.data;

-    const chatModels = ollamaModels.reduce((acc, model) => {
-      acc[model.model] = {
+    const chatModels: Record<string, ChatModel> = {};
+
+    models.forEach((model: any) => {
+      chatModels[model.model] = {
        displayName: model.name,
        model: new ChatOllama({
-          baseUrl: ollamaEndpoint,
+          baseUrl: ollamaApiEndpoint,
          model: model.model,
          temperature: 0.7,
-          keepAlive: keepAlive,
+          keepAlive: getKeepAlive(),
        }),
      };
-
-      return acc;
-    }, {});
+    });

    return chatModels;
  } catch (err) {
-    logger.error(`Error loading Ollama models: ${err}`);
+    console.error(`Error loading Ollama models: ${err}`);
    return {};
  }
 };

-export const loadOllamaEmbeddingsModels = async () => {
-  const ollamaEndpoint = getOllamaApiEndpoint();
+export const loadOllamaEmbeddingModels = async () => {
+  const ollamaApiEndpoint = getOllamaApiEndpoint();

-  if (!ollamaEndpoint) return {};
+  if (!ollamaApiEndpoint) return {};

  try {
-    const response = await axios.get(`${ollamaEndpoint}/api/tags`, {
+    const res = await axios.get(`${ollamaApiEndpoint}/api/tags`, {
      headers: {
        'Content-Type': 'application/json',
      },
    });

-    const { models: ollamaModels } = response.data;
+    const { models } = res.data;

-    const embeddingsModels = ollamaModels.reduce((acc, model) => {
-      acc[model.model] = {
+    const embeddingModels: Record<string, EmbeddingModel> = {};
+
+    models.forEach((model: any) => {
+      embeddingModels[model.model] = {
        displayName: model.name,
        model: new OllamaEmbeddings({
-          baseUrl: ollamaEndpoint,
+          baseUrl: ollamaApiEndpoint,
          model: model.model,
        }),
      };
+    });

-      return acc;
-    }, {});
-
-    return embeddingsModels;
+    return embeddingModels;
  } catch (err) {
-    logger.error(`Error loading Ollama embeddings model: ${err}`);
+    console.error(`Error loading Ollama embeddings models: ${err}`);
    return {};
  }
 };
--- a/src/lib/providers/openai.ts
+++ b/src/lib/providers/openai.ts
@@ -1,89 +1,90 @@
 import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
-import { getOpenaiApiKey } from '../../config';
-import logger from '../../utils/logger';
+import { getOpenaiApiKey } from '../config';
+import { ChatModel, EmbeddingModel } from '.';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { Embeddings } from '@langchain/core/embeddings';
+
+const openaiChatModels: Record<string, string>[] = [
+  {
+    displayName: 'GPT-3.5 Turbo',
+    key: 'gpt-3.5-turbo',
+  },
+  {
+    displayName: 'GPT-4',
+    key: 'gpt-4',
+  },
+  {
+    displayName: 'GPT-4 turbo',
+    key: 'gpt-4-turbo',
+  },
+  {
+    displayName: 'GPT-4 omni',
+    key: 'gpt-4o',
+  },
+  {
+    displayName: 'GPT-4 omni mini',
+    key: 'gpt-4o-mini',
+  },
+];
+
+const openaiEmbeddingModels: Record<string, string>[] = [
+  {
+    displayName: 'Text Embedding 3 Small',
+    key: 'text-embedding-3-small',
+  },
+  {
+    displayName: 'Text Embedding 3 Large',
+    key: 'text-embedding-3-large',
+  },
+];

 export const loadOpenAIChatModels = async () => {
-  const openAIApiKey = getOpenaiApiKey();
+  const openaiApiKey = getOpenaiApiKey();

-  if (!openAIApiKey) return {};
+  if (!openaiApiKey) return {};

  try {
-    const chatModels = {
-      'gpt-3.5-turbo': {
-        displayName: 'GPT-3.5 Turbo',
+    const chatModels: Record<string, ChatModel> = {};
+
+    openaiChatModels.forEach((model) => {
+      chatModels[model.key] = {
+        displayName: model.displayName,
        model: new ChatOpenAI({
-          openAIApiKey,
-          modelName: 'gpt-3.5-turbo',
+          openAIApiKey: openaiApiKey,
+          modelName: model.key,
          temperature: 0.7,
-        }),
-      },
-      'gpt-4': {
-        displayName: 'GPT-4',
-        model: new ChatOpenAI({
-          openAIApiKey,
-          modelName: 'gpt-4',
-          temperature: 0.7,
-        }),
-      },
-      'gpt-4-turbo': {
-        displayName: 'GPT-4 turbo',
-        model: new ChatOpenAI({
-          openAIApiKey,
-          modelName: 'gpt-4-turbo',
-          temperature: 0.7,
-        }),
-      },
-      'gpt-4o': {
-        displayName: 'GPT-4 omni',
-        model: new ChatOpenAI({
-          openAIApiKey,
-          modelName: 'gpt-4o',
-          temperature: 0.7,
-        }),
-      },
-      'gpt-4o-mini': {
-        displayName: 'GPT-4 omni mini',
-        model: new ChatOpenAI({
-          openAIApiKey,
-          modelName: 'gpt-4o-mini',
-          temperature: 0.7,
-        }),
-      },
-    };
+        }) as unknown as BaseChatModel,
+      };
+    });

    return chatModels;
  } catch (err) {
-    logger.error(`Error loading OpenAI models: ${err}`);
+    console.error(`Error loading OpenAI models: ${err}`);
    return {};
  }
 };

-export const loadOpenAIEmbeddingsModels = async () => {
-  const openAIApiKey = getOpenaiApiKey();
+export const loadOpenAIEmbeddingModels = async () => {
+  const openaiApiKey = getOpenaiApiKey();

-  if (!openAIApiKey) return {};
+  if (!openaiApiKey) return {};

  try {
-    const embeddingModels = {
-      'text-embedding-3-small': {
-        displayName: 'Text Embedding 3 Small',
+    const embeddingModels: Record<string, EmbeddingModel> = {};
+
+    openaiEmbeddingModels.forEach((model) => {
+      embeddingModels[model.key] = {
+        displayName: model.displayName,
        model: new OpenAIEmbeddings({
-          openAIApiKey,
-          modelName: 'text-embedding-3-small',
-        }),
-      },
-      'text-embedding-3-large': {
-        displayName: 'Text Embedding 3 Large',
-        model: new OpenAIEmbeddings({
-          openAIApiKey,
-          modelName: 'text-embedding-3-large',
-        }),
-      },
-    };
+          openAIApiKey: openaiApiKey,
+          modelName: model.key,
+        }) as unknown as Embeddings,
+      };
+    });

    return embeddingModels;
  } catch (err) {
-    logger.error(`Error loading OpenAI embeddings model: ${err}`);
+    console.error(`Error loading OpenAI embeddings models: ${err}`);
    return {};
  }
 };
--- a/src/lib/providers/transformers.ts
+++ b/src/lib/providers/transformers.ts
@@ -1,32 +0,0 @@
-import logger from '../../utils/logger';
-import { HuggingFaceTransformersEmbeddings } from '../huggingfaceTransformer';
-
-export const loadTransformersEmbeddingsModels = async () => {
-  try {
-    const embeddingModels = {
-      'xenova-bge-small-en-v1.5': {
-        displayName: 'BGE Small',
-        model: new HuggingFaceTransformersEmbeddings({
-          modelName: 'Xenova/bge-small-en-v1.5',
-        }),
-      },
-      'xenova-gte-small': {
-        displayName: 'GTE Small',
-        model: new HuggingFaceTransformersEmbeddings({
-          modelName: 'Xenova/gte-small',
-        }),
-      },
-      'xenova-bert-base-multilingual-uncased': {
-        displayName: 'Bert Multilingual',
-        model: new HuggingFaceTransformersEmbeddings({
-          modelName: 'Xenova/bert-base-multilingual-uncased',
-        }),
-      },
-    };
-
-    return embeddingModels;
-  } catch (err) {
-    logger.error(`Error loading Transformers embeddings model: ${err}`);
-    return {};
-  }
-};
--- a/src/lib/search/metaSearchAgent.ts
+++ b/src/lib/search/metaSearchAgent.ts
@@ -13,18 +13,17 @@ import {
 } from '@langchain/core/runnables';
 import { BaseMessage } from '@langchain/core/messages';
 import { StringOutputParser } from '@langchain/core/output_parsers';
-import LineListOutputParser from '../lib/outputParsers/listLineOutputParser';
-import LineOutputParser from '../lib/outputParsers/lineOutputParser';
+import LineListOutputParser from '../outputParsers/listLineOutputParser';
+import LineOutputParser from '../outputParsers/lineOutputParser';
 import { getDocumentsFromLinks } from '../utils/documents';
 import { Document } from 'langchain/document';
-import { searchSearxng } from '../lib/searxng';
-import path from 'path';
-import fs from 'fs';
+import { searchSearxng } from '../searxng';
+import path from 'node:path';
+import fs from 'node:fs';
 import computeSimilarity from '../utils/computeSimilarity';
 import formatChatHistoryAsString from '../utils/formatHistory';
 import eventEmitter from 'events';
 import { StreamEvent } from '@langchain/core/tracers/log_stream';
-import { IterableReadableStream } from '@langchain/core/utils/stream';

 export interface MetaSearchAgentType {
  searchAndAnswer: (
@@ -90,7 +89,7 @@ class MetaSearchAgent implements MetaSearchAgentType {
            question = 'summarize';
          }

-          let docs = [];
+          let docs: Document[] = [];

          const linkDocs = await getDocumentsFromLinks({ links });

@@ -311,7 +310,7 @@ class MetaSearchAgent implements MetaSearchAgentType {
        const embeddings = JSON.parse(fs.readFileSync(embeddingsPath, 'utf8'));

        const fileSimilaritySearchObject = content.contents.map(
-          (c: string, i) => {
+          (c: string, i: number) => {
            return {
              fileName: content.title,
              content: c,
@@ -414,6 +413,8 @@ class MetaSearchAgent implements MetaSearchAgentType {

      return sortedDocs;
    }
+
+    return [];
  }

  private processDocs(docs: Document[]) {
@@ -426,7 +427,7 @@ class MetaSearchAgent implements MetaSearchAgentType {
  }

  private async handleStream(
-    stream: IterableReadableStream<StreamEvent>,
+    stream: AsyncGenerator<StreamEvent, any, any>,
    emitter: eventEmitter,
  ) {
    for await (const event of stream) {
--- a/src/lib/searxng.ts
+++ b/src/lib/searxng.ts
@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { getSearxngApiEndpoint } from '../config';
+import { getSearxngApiEndpoint } from './config';

 interface SearxngSearchOptions {
  categories?: string[];
@@ -30,11 +30,12 @@ export const searchSearxng = async (

  if (opts) {
    Object.keys(opts).forEach((key) => {
-      if (Array.isArray(opts[key])) {
-        url.searchParams.append(key, opts[key].join(','));
+      const value = opts[key as keyof SearxngSearchOptions];
+      if (Array.isArray(value)) {
+        url.searchParams.append(key, value.join(','));
        return;
      }
-      url.searchParams.append(key, opts[key]);
+      url.searchParams.append(key, value as string);
    });
  }

--- a/src/lib/types/compute-dot.d.ts
+++ b/src/lib/types/compute-dot.d.ts
@@ -0,0 +1,5 @@
+declare function computeDot(vectorA: number[], vectorB: number[]): number;
+
+declare module 'compute-dot' {
+  export default computeDot;
+}
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
--- a/src/lib/utils/computeSimilarity.ts
+++ b/src/lib/utils/computeSimilarity.ts
@@ -6,7 +6,7 @@ const computeSimilarity = (x: number[], y: number[]): number => {
  const similarityMeasure = getSimilarityMeasure();

  if (similarityMeasure === 'cosine') {
-    return cosineSimilarity(x, y);
+    return cosineSimilarity(x, y) as number;
  } else if (similarityMeasure === 'dot') {
    return dot(x, y);
  }
--- a/src/lib/utils/documents.ts
+++ b/src/lib/utils/documents.ts
@@ -3,7 +3,6 @@ import { htmlToText } from 'html-to-text';
 import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
 import { Document } from '@langchain/core/documents';
 import pdfParse from 'pdf-parse';
-import logger from './logger';

 export const getDocumentsFromLinks = async ({ links }: { links: string[] }) => {
  const splitter = new RecursiveCharacterTextSplitter();
@@ -79,12 +78,13 @@ export const getDocumentsFromLinks = async ({ links }: { links: string[] }) => {

        docs.push(...linkDocs);
      } catch (err) {
-        logger.error(
-          `Error at generating documents from links: ${err.message}`,
+        console.error(
+          'An error occurred while getting documents from links: ',
+          err,
        );
        docs.push(
          new Document({
-            pageContent: `Failed to retrieve content from the link: ${err.message}`,
+            pageContent: `Failed to retrieve content from the link: ${err}`,
            metadata: {
              title: 'Failed to retrieve content',
              url: link,
--- a/src/lib/utils/files.ts
+++ b/src/lib/utils/files.ts
--- a/src/lib/utils/formatHistory.ts
+++ b/src/lib/utils/formatHistory.ts
--- a/src/routes/chats.ts
+++ b/src/routes/chats.ts
@@ -1,66 +0,0 @@
-import express from 'express';
-import logger from '../utils/logger';
-import db from '../db/index';
-import { eq } from 'drizzle-orm';
-import { chats, messages } from '../db/schema';
-
-const router = express.Router();
-
-router.get('/', async (_, res) => {
-  try {
-    let chats = await db.query.chats.findMany();
-
-    chats = chats.reverse();
-
-    return res.status(200).json({ chats: chats });
-  } catch (err) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(`Error in getting chats: ${err.message}`);
-  }
-});
-
-router.get('/:id', async (req, res) => {
-  try {
-    const chatExists = await db.query.chats.findFirst({
-      where: eq(chats.id, req.params.id),
-    });
-
-    if (!chatExists) {
-      return res.status(404).json({ message: 'Chat not found' });
-    }
-
-    const chatMessages = await db.query.messages.findMany({
-      where: eq(messages.chatId, req.params.id),
-    });
-
-    return res.status(200).json({ chat: chatExists, messages: chatMessages });
-  } catch (err) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(`Error in getting chat: ${err.message}`);
-  }
-});
-
-router.delete(`/:id`, async (req, res) => {
-  try {
-    const chatExists = await db.query.chats.findFirst({
-      where: eq(chats.id, req.params.id),
-    });
-
-    if (!chatExists) {
-      return res.status(404).json({ message: 'Chat not found' });
-    }
-
-    await db.delete(chats).where(eq(chats.id, req.params.id)).execute();
-    await db
-      .delete(messages)
-      .where(eq(messages.chatId, req.params.id))
-      .execute();
-
-    return res.status(200).json({ message: 'Chat deleted successfully' });
-  } catch (err) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(`Error in deleting chat: ${err.message}`);
-  }
-});
-
-export default router;
--- a/src/routes/discover.ts
+++ b/src/routes/discover.ts
@@ -1,48 +0,0 @@
-import express from 'express';
-import { searchSearxng } from '../lib/searxng';
-import logger from '../utils/logger';
-
-const router = express.Router();
-
-router.get('/', async (req, res) => {
-  try {
-    const data = (
-      await Promise.all([
-        searchSearxng('site:businessinsider.com AI', {
-          engines: ['bing news'],
-          pageno: 1,
-        }),
-        searchSearxng('site:www.exchangewire.com AI', {
-          engines: ['bing news'],
-          pageno: 1,
-        }),
-        searchSearxng('site:yahoo.com AI', {
-          engines: ['bing news'],
-          pageno: 1,
-        }),
-        searchSearxng('site:businessinsider.com tech', {
-          engines: ['bing news'],
-          pageno: 1,
-        }),
-        searchSearxng('site:www.exchangewire.com tech', {
-          engines: ['bing news'],
-          pageno: 1,
-        }),
-        searchSearxng('site:yahoo.com tech', {
-          engines: ['bing news'],
-          pageno: 1,
-        }),
-      ])
-    )
-      .map((result) => result.results)
-      .flat()
-      .sort(() => Math.random() - 0.5);
-
-    return res.json({ blogs: data });
-  } catch (err: any) {
-    logger.error(`Error in discover route: ${err.message}`);
-    return res.status(500).json({ message: 'An error has occurred' });
-  }
-});
-
-export default router;
--- a/src/routes/images.ts
+++ b/src/routes/images.ts
@@ -1,82 +0,0 @@
-import express from 'express';
-import handleImageSearch from '../chains/imageSearchAgent';
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { getAvailableChatModelProviders } from '../lib/providers';
-import { HumanMessage, AIMessage } from '@langchain/core/messages';
-import logger from '../utils/logger';
-import { ChatOpenAI } from '@langchain/openai';
-import {
-  getCustomOpenaiApiKey,
-  getCustomOpenaiApiUrl,
-  getCustomOpenaiModelName,
-} from '../config';
-
-const router = express.Router();
-
-interface ChatModel {
-  provider: string;
-  model: string;
-}
-
-interface ImageSearchBody {
-  query: string;
-  chatHistory: any[];
-  chatModel?: ChatModel;
-}
-
-router.post('/', async (req, res) => {
-  try {
-    let body: ImageSearchBody = req.body;
-
-    const chatHistory = body.chatHistory.map((msg: any) => {
-      if (msg.role === 'user') {
-        return new HumanMessage(msg.content);
-      } else if (msg.role === 'assistant') {
-        return new AIMessage(msg.content);
-      }
-    });
-
-    const chatModelProviders = await getAvailableChatModelProviders();
-
-    const chatModelProvider =
-      body.chatModel?.provider || Object.keys(chatModelProviders)[0];
-    const chatModel =
-      body.chatModel?.model ||
-      Object.keys(chatModelProviders[chatModelProvider])[0];
-
-    let llm: BaseChatModel | undefined;
-
-    if (body.chatModel?.provider === 'custom_openai') {
-      llm = new ChatOpenAI({
-        modelName: getCustomOpenaiModelName(),
-        openAIApiKey: getCustomOpenaiApiKey(),
-        temperature: 0.7,
-        configuration: {
-          baseURL: getCustomOpenaiApiUrl(),
-        },
-      }) as unknown as BaseChatModel;
-    } else if (
-      chatModelProviders[chatModelProvider] &&
-      chatModelProviders[chatModelProvider][chatModel]
-    ) {
-      llm = chatModelProviders[chatModelProvider][chatModel]
-        .model as unknown as BaseChatModel | undefined;
-    }
-
-    if (!llm) {
-      return res.status(400).json({ message: 'Invalid model selected' });
-    }
-
-    const images = await handleImageSearch(
-      { query: body.query, chat_history: chatHistory },
-      llm,
-    );
-
-    res.status(200).json({ images });
-  } catch (err) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(`Error in image search: ${err.message}`);
-  }
-});
-
-export default router;
--- a/src/routes/index.ts
+++ b/src/routes/index.ts
@@ -1,24 +0,0 @@
-import express from 'express';
-import imagesRouter from './images';
-import videosRouter from './videos';
-import configRouter from './config';
-import modelsRouter from './models';
-import suggestionsRouter from './suggestions';
-import chatsRouter from './chats';
-import searchRouter from './search';
-import discoverRouter from './discover';
-import uploadsRouter from './uploads';
-
-const router = express.Router();
-
-router.use('/images', imagesRouter);
-router.use('/videos', videosRouter);
-router.use('/config', configRouter);
-router.use('/models', modelsRouter);
-router.use('/suggestions', suggestionsRouter);
-router.use('/chats', chatsRouter);
-router.use('/search', searchRouter);
-router.use('/discover', discoverRouter);
-router.use('/uploads', uploadsRouter);
-
-export default router;
--- a/src/routes/models.ts
+++ b/src/routes/models.ts
@@ -1,36 +0,0 @@
-import express from 'express';
-import logger from '../utils/logger';
-import {
-  getAvailableChatModelProviders,
-  getAvailableEmbeddingModelProviders,
-} from '../lib/providers';
-
-const router = express.Router();
-
-router.get('/', async (req, res) => {
-  try {
-    const [chatModelProviders, embeddingModelProviders] = await Promise.all([
-      getAvailableChatModelProviders(),
-      getAvailableEmbeddingModelProviders(),
-    ]);
-
-    Object.keys(chatModelProviders).forEach((provider) => {
-      Object.keys(chatModelProviders[provider]).forEach((model) => {
-        delete chatModelProviders[provider][model].model;
-      });
-    });
-
-    Object.keys(embeddingModelProviders).forEach((provider) => {
-      Object.keys(embeddingModelProviders[provider]).forEach((model) => {
-        delete embeddingModelProviders[provider][model].model;
-      });
-    });
-
-    res.status(200).json({ chatModelProviders, embeddingModelProviders });
-  } catch (err) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(err.message);
-  }
-});
-
-export default router;
--- a/src/routes/search.ts
+++ b/src/routes/search.ts
@@ -1,156 +0,0 @@
-import express from 'express';
-import logger from '../utils/logger';
-import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import type { Embeddings } from '@langchain/core/embeddings';
-import { ChatOpenAI } from '@langchain/openai';
-import {
-  getAvailableChatModelProviders,
-  getAvailableEmbeddingModelProviders,
-} from '../lib/providers';
-import { searchHandlers } from '../websocket/messageHandler';
-import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { MetaSearchAgentType } from '../search/metaSearchAgent';
-import {
-  getCustomOpenaiApiKey,
-  getCustomOpenaiApiUrl,
-  getCustomOpenaiModelName,
-} from '../config';
-
-const router = express.Router();
-
-interface chatModel {
-  provider: string;
-  model: string;
-  customOpenAIKey?: string;
-  customOpenAIBaseURL?: string;
-}
-
-interface embeddingModel {
-  provider: string;
-  model: string;
-}
-
-interface ChatRequestBody {
-  optimizationMode: 'speed' | 'balanced';
-  focusMode: string;
-  chatModel?: chatModel;
-  embeddingModel?: embeddingModel;
-  query: string;
-  history: Array<[string, string]>;
-}
-
-router.post('/', async (req, res) => {
-  try {
-    const body: ChatRequestBody = req.body;
-
-    if (!body.focusMode || !body.query) {
-      return res.status(400).json({ message: 'Missing focus mode or query' });
-    }
-
-    body.history = body.history || [];
-    body.optimizationMode = body.optimizationMode || 'balanced';
-
-    const history: BaseMessage[] = body.history.map((msg) => {
-      if (msg[0] === 'human') {
-        return new HumanMessage({
-          content: msg[1],
-        });
-      } else {
-        return new AIMessage({
-          content: msg[1],
-        });
-      }
-    });
-
-    const [chatModelProviders, embeddingModelProviders] = await Promise.all([
-      getAvailableChatModelProviders(),
-      getAvailableEmbeddingModelProviders(),
-    ]);
-
-    const chatModelProvider =
-      body.chatModel?.provider || Object.keys(chatModelProviders)[0];
-    const chatModel =
-      body.chatModel?.model ||
-      Object.keys(chatModelProviders[chatModelProvider])[0];
-
-    const embeddingModelProvider =
-      body.embeddingModel?.provider || Object.keys(embeddingModelProviders)[0];
-    const embeddingModel =
-      body.embeddingModel?.model ||
-      Object.keys(embeddingModelProviders[embeddingModelProvider])[0];
-
-    let llm: BaseChatModel | undefined;
-    let embeddings: Embeddings | undefined;
-
-    if (body.chatModel?.provider === 'custom_openai') {
-      llm = new ChatOpenAI({
-        modelName: body.chatModel?.model || getCustomOpenaiModelName(),
-        openAIApiKey: body.chatModel?.customOpenAIKey || getCustomOpenaiApiKey(),
-        temperature: 0.7,
-        configuration: {
-          baseURL: body.chatModel?.customOpenAIBaseURL || getCustomOpenaiApiUrl(),
-        },
-      }) as unknown as BaseChatModel;
-    } else if (
-      chatModelProviders[chatModelProvider] &&
-      chatModelProviders[chatModelProvider][chatModel]
-    ) {
-      llm = chatModelProviders[chatModelProvider][chatModel]
-        .model as unknown as BaseChatModel | undefined;
-    }
-
-    if (
-      embeddingModelProviders[embeddingModelProvider] &&
-      embeddingModelProviders[embeddingModelProvider][embeddingModel]
-    ) {
-      embeddings = embeddingModelProviders[embeddingModelProvider][
-        embeddingModel
-      ].model as Embeddings | undefined;
-    }
-
-    if (!llm || !embeddings) {
-      return res.status(400).json({ message: 'Invalid model selected' });
-    }
-
-    const searchHandler: MetaSearchAgentType = searchHandlers[body.focusMode];
-
-    if (!searchHandler) {
-      return res.status(400).json({ message: 'Invalid focus mode' });
-    }
-
-    const emitter = await searchHandler.searchAndAnswer(
-      body.query,
-      history,
-      llm,
-      embeddings,
-      body.optimizationMode,
-      [],
-    );
-
-    let message = '';
-    let sources = [];
-
-    emitter.on('data', (data) => {
-      const parsedData = JSON.parse(data);
-      if (parsedData.type === 'response') {
-        message += parsedData.data;
-      } else if (parsedData.type === 'sources') {
-        sources = parsedData.data;
-      }
-    });
-
-    emitter.on('end', () => {
-      res.status(200).json({ message, sources });
-    });
-
-    emitter.on('error', (data) => {
-      const parsedData = JSON.parse(data);
-      res.status(500).json({ message: parsedData.data });
-    });
-  } catch (err: any) {
-    logger.error(`Error in getting search results: ${err.message}`);
-    res.status(500).json({ message: 'An error has occurred.' });
-  }
-});
-
-export default router;
--- a/src/routes/suggestions.ts
+++ b/src/routes/suggestions.ts
@@ -1,81 +0,0 @@
-import express from 'express';
-import generateSuggestions from '../chains/suggestionGeneratorAgent';
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { getAvailableChatModelProviders } from '../lib/providers';
-import { HumanMessage, AIMessage } from '@langchain/core/messages';
-import logger from '../utils/logger';
-import { ChatOpenAI } from '@langchain/openai';
-import {
-  getCustomOpenaiApiKey,
-  getCustomOpenaiApiUrl,
-  getCustomOpenaiModelName,
-} from '../config';
-
-const router = express.Router();
-
-interface ChatModel {
-  provider: string;
-  model: string;
-}
-
-interface SuggestionsBody {
-  chatHistory: any[];
-  chatModel?: ChatModel;
-}
-
-router.post('/', async (req, res) => {
-  try {
-    let body: SuggestionsBody = req.body;
-
-    const chatHistory = body.chatHistory.map((msg: any) => {
-      if (msg.role === 'user') {
-        return new HumanMessage(msg.content);
-      } else if (msg.role === 'assistant') {
-        return new AIMessage(msg.content);
-      }
-    });
-
-    const chatModelProviders = await getAvailableChatModelProviders();
-
-    const chatModelProvider =
-      body.chatModel?.provider || Object.keys(chatModelProviders)[0];
-    const chatModel =
-      body.chatModel?.model ||
-      Object.keys(chatModelProviders[chatModelProvider])[0];
-
-    let llm: BaseChatModel | undefined;
-
-    if (body.chatModel?.provider === 'custom_openai') {
-      llm = new ChatOpenAI({
-        modelName: getCustomOpenaiModelName(),
-        openAIApiKey: getCustomOpenaiApiKey(),
-        temperature: 0.7,
-        configuration: {
-          baseURL: getCustomOpenaiApiUrl(),
-        },
-      }) as unknown as BaseChatModel;
-    } else if (
-      chatModelProviders[chatModelProvider] &&
-      chatModelProviders[chatModelProvider][chatModel]
-    ) {
-      llm = chatModelProviders[chatModelProvider][chatModel]
-        .model as unknown as BaseChatModel | undefined;
-    }
-
-    if (!llm) {
-      return res.status(400).json({ message: 'Invalid model selected' });
-    }
-
-    const suggestions = await generateSuggestions(
-      { chat_history: chatHistory },
-      llm,
-    );
-
-    res.status(200).json({ suggestions: suggestions });
-  } catch (err) {
-    res.status(500).json({ message: 'An error has occurred.' });
-    logger.error(`Error in generating suggestions: ${err.message}`);
-  }
-});
-
-export default router;
--- a/src/routes/uploads.ts
+++ b/src/routes/uploads.ts
@@ -1,151 +0,0 @@
-import express from 'express';
-import logger from '../utils/logger';
-import multer from 'multer';
-import path from 'path';
-import crypto from 'crypto';
-import fs from 'fs';
-import { Embeddings } from '@langchain/core/embeddings';
-import { getAvailableEmbeddingModelProviders } from '../lib/providers';
-import { PDFLoader } from '@langchain/community/document_loaders/fs/pdf';
-import { DocxLoader } from '@langchain/community/document_loaders/fs/docx';
-import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
-import { Document } from 'langchain/document';
-
-const router = express.Router();
-
-const splitter = new RecursiveCharacterTextSplitter({
-  chunkSize: 500,
-  chunkOverlap: 100,
-});
-
-const storage = multer.diskStorage({
-  destination: (req, file, cb) => {
-    cb(null, path.join(process.cwd(), './uploads'));
-  },
-  filename: (req, file, cb) => {
-    const splitedFileName = file.originalname.split('.');
-    const fileExtension = splitedFileName[splitedFileName.length - 1];
-    if (!['pdf', 'docx', 'txt'].includes(fileExtension)) {
-      return cb(new Error('File type is not supported'), '');
-    }
-    cb(null, `${crypto.randomBytes(16).toString('hex')}.${fileExtension}`);
-  },
-});
-
-const upload = multer({ storage });
-
-router.post(
-  '/',
-  upload.fields([
-    { name: 'files' },
-    { name: 'embedding_model', maxCount: 1 },
-    { name: 'embedding_model_provider', maxCount: 1 },
-  ]),
-  async (req, res) => {
-    try {
-      const { embedding_model, embedding_model_provider } = req.body;
-
-      if (!embedding_model || !embedding_model_provider) {
-        res
-          .status(400)
-          .json({ message: 'Missing embedding model or provider' });
-        return;
-      }
-
-      const embeddingModels = await getAvailableEmbeddingModelProviders();
-      const provider =
-        embedding_model_provider ?? Object.keys(embeddingModels)[0];
-      const embeddingModel: Embeddings =
-        embedding_model ?? Object.keys(embeddingModels[provider])[0];
-
-      let embeddingsModel: Embeddings | undefined;
-
-      if (
-        embeddingModels[provider] &&
-        embeddingModels[provider][embeddingModel]
-      ) {
-        embeddingsModel = embeddingModels[provider][embeddingModel].model as
-          | Embeddings
-          | undefined;
-      }
-
-      if (!embeddingsModel) {
-        res.status(400).json({ message: 'Invalid LLM model selected' });
-        return;
-      }
-
-      const files = req.files['files'] as Express.Multer.File[];
-      if (!files || files.length === 0) {
-        res.status(400).json({ message: 'No files uploaded' });
-        return;
-      }
-
-      await Promise.all(
-        files.map(async (file) => {
-          let docs: Document[] = [];
-
-          if (file.mimetype === 'application/pdf') {
-            const loader = new PDFLoader(file.path);
-            docs = await loader.load();
-          } else if (
-            file.mimetype ===
-            'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-          ) {
-            const loader = new DocxLoader(file.path);
-            docs = await loader.load();
-          } else if (file.mimetype === 'text/plain') {
-            const text = fs.readFileSync(file.path, 'utf-8');
-            docs = [
-              new Document({
-                pageContent: text,
-                metadata: {
-                  title: file.originalname,
-                },
-              }),
-            ];
-          }
-
-          const splitted = await splitter.splitDocuments(docs);
-
-          const json = JSON.stringify({
-            title: file.originalname,
-            contents: splitted.map((doc) => doc.pageContent),
-          });
-
-          const pathToSave = file.path.replace(/\.\w+$/, '-extracted.json');
-          fs.writeFileSync(pathToSave, json);
-
-          const embeddings = await embeddingsModel.embedDocuments(
-            splitted.map((doc) => doc.pageContent),
-          );
-
-          const embeddingsJSON = JSON.stringify({
-            title: file.originalname,
-            embeddings: embeddings,
-          });
-
-          const pathToSaveEmbeddings = file.path.replace(
-            /\.\w+$/,
-            '-embeddings.json',
-          );
-          fs.writeFileSync(pathToSaveEmbeddings, embeddingsJSON);
-        }),
-      );
-
-      res.status(200).json({
-        files: files.map((file) => {
-          return {
-            fileName: file.originalname,
-            fileExtension: file.filename.split('.').pop(),
-            fileId: file.filename.replace(/\.\w+$/, ''),
-          };
-        }),
-      });
-    } catch (err: any) {
-      logger.error(`Error in uploading file results: ${err.message}`);
-      res.status(500).json({ message: 'An error has occurred.' });
-    }
-  },
-);
-
-export default router;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
ItzCrazyKns	403d13eb50	feat(package): update scripts	2025-03-19 16:34:55 +05:30
ItzCrazyKns	217736d05a	feat(app): remove backend	2025-03-19 16:23:27 +05:30
ItzCrazyKns	8a24572cd2	feat(app): add upload functionality	2025-03-19 15:32:32 +05:30
ItzCrazyKns	649c68f292	feat(ui): fix type errors	2025-03-19 13:42:28 +05:30
ItzCrazyKns	bab5dba6e1	feat(app): port history saving features	2025-03-19 13:42:15 +05:30
ItzCrazyKns	c24edac16d	feat(app): add chat functionality	2025-03-19 13:41:52 +05:30
ItzCrazyKns	3150c21f17	feat(icons): fix type errors	2025-03-19 13:41:01 +05:30
ItzCrazyKns	c46fd7a9c8	feat(utils): add files utils, remove logger, fix API url	2025-03-19 13:40:35 +05:30
ItzCrazyKns	bab32e8d70	feat(app): add suggestions route	2025-03-19 13:40:10 +05:30
ItzCrazyKns	1130746f5d	feat(app): add image & video search functionality	2025-03-19 13:38:40 +05:30
ItzCrazyKns	d1e9361665	feat(routes): add discover route	2025-03-19 13:37:54 +05:30
ItzCrazyKns	3bf2337697	feat(app): add db & schema	2025-03-19 13:37:01 +05:30
ItzCrazyKns	ee6e197ec0	feat(app): lint & beautify	2025-03-18 11:29:04 +05:30
ItzCrazyKns	32f26bb4e8	feat(app): add groq, gemini & anthropic provider	2025-03-18 11:28:47 +05:30
ItzCrazyKns	4cb20542a5	feat(config): update file path, add post endpoint	2025-03-18 10:33:32 +05:30
ItzCrazyKns	97f6196d9b	feat(app): add GET config route	2025-03-18 10:25:09 +05:30
ItzCrazyKns	6c227cab6f	feat(providers): move providers to UI	2025-03-18 10:24:51 +05:30
ItzCrazyKns	e9e34ddff9	feat(ui): add meta search agent	2025-03-18 10:24:33 +05:30
ItzCrazyKns	e29a08dc46	feat(ui): add necessary utils	2025-03-18 10:24:16 +05:30
ItzCrazyKns	5c313e9bed	feat(ui): update packages, add config, add searxng	2025-03-18 10:23:59 +05:30
ItzCrazyKns	6b5bd9d79b	feat(prompts): move to UI	2025-03-18 10:23:21 +05:30
ItzCrazyKns	64d2a467b0	Merge pull request #672 from sjiampojamarn/scrolling Only set scrollIntoView for user msg.	2025-03-17 12:03:05 +05:30
sjiampojamarn	9a2c4fe3b6	Only set scrollIntoView for user msg.	2025-03-16 22:15:58 -07:00
ItzCrazyKns	060c68a900	feat(message-box): lint & beautify	2025-03-14 22:05:07 +05:30
ItzCrazyKns	e6b87f89ec	feat(sample-config): add custom openai model name	2025-03-08 20:08:27 +05:30
ItzCrazyKns	89b5229ce9	Merge pull request #663 from ericdachen/master Update Readme	2025-03-05 11:11:07 +05:30
ItzCrazyKns	7756340dd9	Update README.md	2025-03-05 11:09:19 +05:30
ItzCrazyKns	bbd2e9c359	feat(readme): update warp banner	2025-03-05 11:05:25 +05:30
ItzCrazyKns	a32eb1dda3	feat(readme): lint & beautify, update anchor URL	2025-03-05 10:55:02 +05:30
Eric Chen	aa834f7f04	Update README.md	2025-03-04 14:45:10 -05:00
Eric Chen	064c0fbe42	Update README.md	2025-03-04 12:16:10 -05:00
Eric Chen	bf4cf8eaeb	Update README.md	2025-03-04 12:14:17 -05:00
ItzCrazyKns	a24992a3db	Merge pull request #655 from ShortCipher5/patch-1 chore: Add Sealos 1-click deployment	2025-03-01 21:56:01 +05:30
ShortCipher5	d584067bb1	Update README.md	2025-02-27 23:26:45 -08:00
ItzCrazyKns	df4350f966	Merge branch 'master' of https://github.com/ItzCrazyKns/Perplexica	2025-02-26 10:40:34 +05:30
ItzCrazyKns	652ca2fdf4	Merge pull request #649 from QuietlyChan/fix/light-theme-ui-bug fix(ui): improve dark mode text color for attachment buttons	2025-02-26 10:36:41 +05:30
QuietlyChan	216576128d	fix(ui): update attachment text color for light and dark modes	2025-02-25 19:26:58 +08:00
QuietlyChan	bb3f180583	fix(ui): improve dark mode text color for attachment buttons	2025-02-25 17:26:33 +08:00
ItzCrazyKns	4d24d73161	Merge pull request #631 from user1007017/patch-1 Update README.md grammatical error	2025-02-20 10:37:33 +05:30
wellCh4n	2e166c217b	fix(MessageBox): break too long message title	2025-02-19 10:34:51 +08:00
ItzCrazyKns	4c73caadf6	feat(custom-openai): save live changes	2025-02-17 16:24:41 +05:30
user1007017	5f0b87f4a9	Update README.md	2025-02-15 19:06:46 +01:00
ItzCrazyKns	115e6b2a71	Merge branch 'master' of https://github.com/ItzCrazyKns/Perplexica	2025-02-15 12:52:30 +05:30
ItzCrazyKns	a5c79c92ed	feat(settings): add embedding provider settings	2025-02-15 12:52:27 +05:30
ItzCrazyKns	db3cea446e	Update UPDATING.md	2025-02-15 12:33:43 +05:30