Merge 9f4ae1baac into f37686189e

- Add business routes and middleware\n- Update search and database services\n- Improve health check implementation\n- Update CI workflow configuration

.env.example

@@ -0,0 +1,11 @@
+PORT=3000
+NODE_ENV=development
+SUPABASE_URL=your_supabase_url
+SUPABASE_KEY=your_supabase_key
+OLLAMA_URL=http://localhost:11434
+OLLAMA_MODEL=llama2
+SEARXNG_URL=http://localhost:4000
+SEARXNG_INSTANCES=["http://localhost:4000"]
+MAX_RESULTS_PER_QUERY=50
+CACHE_DURATION_HOURS=24
+CACHE_DURATION_DAYS=7

.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+---
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v2
+      with:
+        node-version: '18'
+        
+    - name: Install dependencies
+      run: npm ci
+      
+    - name: Run tests
+      run: npm test
+      
+    - name: Run type check
+      run: npm run build 

.github/workflows/docker-build.yaml

@@ -8,12 +8,18 @@ on:
     types: [published]
 
 jobs:
-  build-amd64:
+  build-and-push:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        service: [backend, app]
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
 
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
         with:
@@ -30,109 +36,38 @@ jobs:
         id: version
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
 
-      - name: Build and push AMD64 Docker image
+      - name: Build and push Docker image for ${{ matrix.service }}
         if: github.ref == 'refs/heads/master' && github.event_name == 'push'
         run: |
-          DOCKERFILE=app.dockerfile
-          IMAGE_NAME=perplexica
-          docker buildx build --platform linux/amd64 \
-            --cache-from=type=registry,ref=itzcrazykns1337/${IMAGE_NAME}:amd64 \
+          docker buildx create --use
+          if [[ "${{ matrix.service }}" == "backend" ]]; then \
+            DOCKERFILE=backend.dockerfile; \
+            IMAGE_NAME=perplexica-backend; \
+          else \
+            DOCKERFILE=app.dockerfile; \
+            IMAGE_NAME=perplexica-frontend; \
+          fi
+          docker buildx build --platform linux/amd64,linux/arm64 \
+            --cache-from=type=registry,ref=itzcrazykns1337/${IMAGE_NAME}:main \
             --cache-to=type=inline \
-            --provenance false \
             -f $DOCKERFILE \
-            -t itzcrazykns1337/${IMAGE_NAME}:amd64 \
+            -t itzcrazykns1337/${IMAGE_NAME}:main \
             --push .
 
-      - name: Build and push AMD64 release Docker image
+      - name: Build and push release Docker image for ${{ matrix.service }}
         if: github.event_name == 'release'
         run: |
-          DOCKERFILE=app.dockerfile
-          IMAGE_NAME=perplexica
-          docker buildx build --platform linux/amd64 \
-            --cache-from=type=registry,ref=itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}-amd64 \
+          docker buildx create --use
+          if [[ "${{ matrix.service }}" == "backend" ]]; then \
+            DOCKERFILE=backend.dockerfile; \
+            IMAGE_NAME=perplexica-backend; \
+          else \
+            DOCKERFILE=app.dockerfile; \
+            IMAGE_NAME=perplexica-frontend; \
+          fi
+          docker buildx build --platform linux/amd64,linux/arm64 \
+            --cache-from=type=registry,ref=itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }} \
             --cache-to=type=inline \
-            --provenance false \
             -f $DOCKERFILE \
-            -t itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}-amd64 \
+            -t itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }} \
             --push .
-
-  build-arm64:
-    runs-on: ubuntu-24.04-arm
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-        with:
-          install: true
-
-      - name: Log in to DockerHub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Extract version from release tag
-        if: github.event_name == 'release'
-        id: version
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-
-      - name: Build and push ARM64 Docker image
-        if: github.ref == 'refs/heads/master' && github.event_name == 'push'
-        run: |
-          DOCKERFILE=app.dockerfile
-          IMAGE_NAME=perplexica
-          docker buildx build --platform linux/arm64 \
-            --cache-from=type=registry,ref=itzcrazykns1337/${IMAGE_NAME}:arm64 \
-            --cache-to=type=inline \
-            --provenance false \
-            -f $DOCKERFILE \
-            -t itzcrazykns1337/${IMAGE_NAME}:arm64 \
-            --push .
-
-      - name: Build and push ARM64 release Docker image
-        if: github.event_name == 'release'
-        run: |
-          DOCKERFILE=app.dockerfile
-          IMAGE_NAME=perplexica
-          docker buildx build --platform linux/arm64 \
-            --cache-from=type=registry,ref=itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}-arm64 \
-            --cache-to=type=inline \
-            --provenance false \
-            -f $DOCKERFILE \
-            -t itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}-arm64 \
-            --push .
-
-  manifest:
-    needs: [build-amd64, build-arm64]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Log in to DockerHub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Extract version from release tag
-        if: github.event_name == 'release'
-        id: version
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-
-      - name: Create and push multi-arch manifest for main
-        if: github.ref == 'refs/heads/master' && github.event_name == 'push'
-        run: |
-          IMAGE_NAME=perplexica
-          docker manifest create itzcrazykns1337/${IMAGE_NAME}:main \
-            --amend itzcrazykns1337/${IMAGE_NAME}:amd64 \
-            --amend itzcrazykns1337/${IMAGE_NAME}:arm64
-          docker manifest push itzcrazykns1337/${IMAGE_NAME}:main
-
-      - name: Create and push multi-arch manifest for releases
-        if: github.event_name == 'release'
-        run: |
-          IMAGE_NAME=perplexica
-          docker manifest create itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }} \
-            --amend itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}-amd64 \
-            --amend itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}-arm64
-          docker manifest push itzcrazykns1337/${IMAGE_NAME}:${{ env.RELEASE_VERSION }}

.gitignore

@@ -1,39 +1,32 @@
-# Node.js
-node_modules/
-npm-debug.log
-yarn-error.log
-
-# Build output
-.next/
-out/
-dist/
-
-# IDE/Editor specific
-.vscode/
-.idea/
-*.iml
-
 # Environment variables
 .env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
+.env.*
+!.env.example
 
-# Config files
-config.toml
+# Dependencies
+node_modules/
+yarn-error.log
+npm-debug.log
 
-# Log files
-logs/
-*.log
+# Build outputs
+dist/
+build/
+.next/
 
-# Testing
-/coverage/
+# IDE/Editor
+.vscode/
+.idea/
+*.swp
+*.swo
 
-# Miscellaneous
+# OS
 .DS_Store
 Thumbs.db
 
-# Db
-db.sqlite
-/searxng
+# Logs
+logs/
+*.log
+
+# Cache
+.cache/
+.npm/

.prettierrc.js

@@ -6,6 +6,7 @@ const config = {
   endOfLine: 'auto',
   singleQuote: true,
   tabWidth: 2,
+  semi: true,
 };
 
 module.exports = config;

CONTRIBUTING.md

@@ -1,43 +1,32 @@
 # How to Contribute to Perplexica
 
-Thanks for your interest in contributing to Perplexica! Your help makes this project better. This guide explains how to contribute effectively.
-
-Perplexica is a modern AI chat application with advanced search capabilities.
+Hey there, thanks for deciding to contribute to Perplexica. Anything you help with will support the development of Perplexica and will make it better. Let's walk you through the key aspects to ensure your contributions are effective and in harmony with the project's setup.
 
 ## Project Structure
 
-Perplexica's codebase is organized as follows:
+Perplexica's design consists of two main domains:
 
-- **UI Components and Pages**:
-  - **Components (`src/components`)**: Reusable UI components.
-  - **Pages and Routes (`src/app`)**: Next.js app directory structure with page components.
-    - Main app routes include: home (`/`), chat (`/c`), discover (`/discover`), library (`/library`), and settings (`/settings`).
-  - **API Routes (`src/app/api`)**: API endpoints implemented with Next.js API routes.
-    - `/api/chat`: Handles chat interactions.
-    - `/api/search`: Provides direct access to Perplexica's search capabilities.
-    - Other endpoints for models, files, and suggestions.
-- **Backend Logic (`src/lib`)**: Contains all the backend functionality including search, database, and API logic.
-  - The search functionality is present inside `src/lib/search` directory.
-  - All of the focus modes are implemented using the Meta Search Agent class in `src/lib/search/metaSearchAgent.ts`.
-  - Database functionality is in `src/lib/db`.
-  - Chat model and embedding model providers are managed in `src/lib/providers`.
-  - Prompt templates and LLM chain definitions are in `src/lib/prompts` and `src/lib/chains` respectively.
-
-## API Documentation
-
-Perplexica exposes several API endpoints for programmatic access, including:
-
-- **Search API**: Access Perplexica's advanced search capabilities directly via the `/api/search` endpoint. For detailed documentation, see `docs/api/search.md`.
+- **Frontend (`ui` directory)**: This is a Next.js application holding all user interface components. It's a self-contained environment that manages everything the user interacts with.
+- **Backend (root and `src` directory)**: The backend logic is situated in the `src` folder, but the root directory holds the main `package.json` for backend dependency management.
+  - All of the focus modes are created using the Meta Search Agent class present in `src/search/metaSearchAgent.ts`. The main logic behind Perplexica lies there.
 
 ## Setting Up Your Environment
 
 Before diving into coding, setting up your local environment is key. Here's what you need to do:
 
+### Backend
+
 1. In the root directory, locate the `sample.config.toml` file.
-2. Rename it to `config.toml` and fill in the necessary configuration fields.
-3. Run `npm install` to install all dependencies.
-4. Run `npm run db:push` to set up the local sqlite database.
-5. Use `npm run dev` to start the application in development mode.
+2. Rename it to `config.toml` and fill in the necessary configuration fields specific to the backend.
+3. Run `npm install` to install dependencies.
+4. Run `npm run db:push` to set up the local sqlite.
+5. Use `npm run dev` to start the backend in development mode.
+
+### Frontend
+
+1. Navigate to the `ui` folder and repeat the process of renaming `.env.example` to `.env`, making sure to provide the frontend-specific variables.
+2. Execute `npm install` within the `ui` directory to get the frontend dependencies ready.
+3. Launch the frontend development server with `npm run dev`.
 
 **Please note**: Docker configurations are present for setting up production environments, whereas `npm run dev` is used for development purposes.
 

README.md

@@ -1,193 +1,120 @@
-# 🚀 Perplexica - An AI-powered search engine 🔎 <!-- omit in toc -->
+# BizSearch
 
-<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>
+A tool for finding and analyzing local businesses using AI-powered data extraction.
 
-### [Warp, the AI Devtool that lives in your terminal](https://www.warp.dev/perplexica)
+## Prerequisites
 
-[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?)
-
-## Table of Contents <!-- omit in toc -->
-
-- [Overview](#overview)
-- [Preview](#preview)
-- [Features](#features)
-- [Installation](#installation)
-  - [Getting Started with Docker (Recommended)](#getting-started-with-docker-recommended)
-  - [Non-Docker Installation](#non-docker-installation)
-  - [Ollama Connection Errors](#ollama-connection-errors)
-- [Using as a Search Engine](#using-as-a-search-engine)
-- [Using Perplexica's API](#using-perplexicas-api)
-- [Expose Perplexica to a network](#expose-perplexica-to-network)
-- [One-Click Deployment](#one-click-deployment)
-- [Upcoming Features](#upcoming-features)
-- [Support Us](#support-us)
-  - [Donations](#donations)
-- [Contribution](#contribution)
-- [Help and Support](#help-and-support)
-
-## Overview
-
-Perplexica is an open-source AI-powered searching tool or an AI-powered search engine that goes deep into the internet to find answers. Inspired by Perplexity AI, it's an open-source option that not just searches the web but understands your questions. It uses advanced machine learning algorithms like similarity searching and embeddings to refine results and provides clear answers with sources cited.
-
-Using SearxNG to stay current and fully open source, Perplexica ensures you always get the most up-to-date information without compromising your privacy.
-
-Want to know more about its architecture and how it works? You can read it [here](https://github.com/ItzCrazyKns/Perplexica/tree/master/docs/architecture/README.md).
-
-## Preview
-
-![video-preview](.assets/perplexica-preview.gif)
-
-## Features
-
-- **Local LLMs**: You can make use local LLMs such as Llama3 and Mixtral using Ollama.
-- **Two Main Modes:**
-  - **Copilot Mode:** (In development) Boosts search by generating different queries to find more relevant internet sources. Like normal search instead of just using the context by SearxNG, it visits the top matches and tries to find relevant sources to the user's query directly from the page.
-  - **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 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.
-  - **Reddit Search Mode:** Searches Reddit for discussions and opinions related to the query.
-- **Current Information:** Some search tools might give you outdated info because they use data from crawling bots and convert them into embeddings and store them in a index. Unlike them, Perplexica uses SearxNG, a metasearch engine to get the results and rerank and get the most relevant source out of it, ensuring you always get the latest information without the overhead of daily data updates.
-- **API**: Integrate Perplexica into your existing applications and make use of its capibilities.
-
-It has many more features like image and video search. Some of the planned features are mentioned in [upcoming features](#upcoming-features).
+- Node.js 16+
+- Ollama (for local LLM)
+- SearxNG instance
 
 ## Installation
 
-There are mainly 2 ways of installing Perplexica - With Docker, Without Docker. Using Docker is highly recommended.
+1. Install Ollama:
+```bash
+# On macOS
+brew install ollama
+```
 
-### Getting Started with Docker (Recommended)
+2. Start Ollama:
+```bash
+# Start and enable on login
+brew services start ollama
 
-1. Ensure Docker is installed and running on your system.
-2. Clone the Perplexica repository:
+# Or run without auto-start
+/usr/local/opt/ollama/bin/ollama serve
+```
 
-   ```bash
-   git clone https://github.com/ItzCrazyKns/Perplexica.git
-   ```
+3. Pull the required model:
+```bash
+ollama pull mistral
+```
 
-3. After cloning, navigate to the directory containing the project files.
+4. Clone and set up the project:
+```bash
+git clone https://github.com/yourusername/bizsearch.git
+cd bizsearch
+npm install
+```
 
-4. Rename the `sample.config.toml` file to `config.toml`. For Docker setups, you need only fill in the following fields:
+5. Configure environment:
+```bash
+cp .env.example .env
+# Edit .env with your settings
+```
 
-   - `OPENAI`: Your OpenAI API key. **You only need to fill this if you wish to use OpenAI's models**.
-   - `OLLAMA`: Your Ollama API URL. You should enter it as `http://host.docker.internal:PORT_NUMBER`. If you installed Ollama on port 11434, use `http://host.docker.internal:11434`. For other ports, adjust accordingly. **You need to fill this if you wish to use Ollama's models instead of OpenAI's**.
-   - `GROQ`: Your Groq API key. **You only need to fill this if you wish to use Groq's hosted models**.
-   - `ANTHROPIC`: Your Anthropic API key. **You only need to fill this if you wish to use Anthropic models**.
+6. Start the application:
+```bash
+npm run dev
+```
 
-     **Note**: You can change these after starting Perplexica from the settings dialog.
+7. Open http://localhost:3000 in your browser
 
-   - `SIMILARITY_MEASURE`: The similarity measure to use (This is filled by default; you can leave it as is if you are unsure about it.)
+## Troubleshooting
 
-5. Ensure you are in the directory containing the `docker-compose.yaml` file and execute:
+If Ollama fails to start:
+```bash
+# Stop any existing instance
+brew services stop ollama
+# Wait a few seconds
+sleep 5
+# Start again
+brew services start ollama
+```
 
-   ```bash
-   docker compose up -d
-   ```
+To verify Ollama is running:
+```bash
+curl http://localhost:11434/api/version
+```
 
-6. Wait a few minutes for the setup to complete. You can access Perplexica at http://localhost:3000 in your web browser.
+## Features
 
-**Note**: After the containers are built, you can start Perplexica directly from Docker without having to open a terminal.
+- Business search with location filtering
+- Contact information extraction
+- AI-powered data validation
+- Clean, user-friendly interface
+- Service health monitoring
 
-### Non-Docker Installation
+## Configuration
 
-1. Install SearXNG and allow `JSON` format in the SearXNG settings.
-2. Clone the repository and rename the `sample.config.toml` file to `config.toml` in the root directory. Ensure you complete all required fields in this file.
-3. After populating the configuration run `npm i`.
-4. Install the dependencies and then execute `npm run build`.
-5. Finally, start the app by running `npm rum start`
+Key environment variables:
+- `SEARXNG_URL`: Your SearxNG instance URL
+- `OLLAMA_URL`: Ollama API endpoint (default: http://localhost:11434)
+- `SUPABASE_URL`: Your Supabase project URL
+- `SUPABASE_ANON_KEY`: Your Supabase anonymous key
+- `CACHE_DURATION_DAYS`: How long to cache results (default: 7)
 
-**Note**: Using Docker is recommended as it simplifies the setup process, especially for managing environment variables and dependencies.
+## Supabase Setup
 
-See the [installation documentation](https://github.com/ItzCrazyKns/Perplexica/tree/master/docs/installation) for more information like updating, etc.
+1. Create a new Supabase project
+2. Run the SQL commands in `db/init.sql` to create the cache table
+3. Copy your project URL and anon key to `.env`
 
-### Ollama Connection Errors
+## License
 
-If you're encountering an Ollama connection error, it is likely due to the backend being unable to connect to Ollama's API. To fix this issue you can:
+MIT
 
-1. **Check your Ollama API URL:** Ensure that the API URL is correctly set in the settings menu.
-2. **Update API URL Based on OS:**
+## Cache Management
 
-   - **Windows:** Use `http://host.docker.internal:11434`
-   - **Mac:** Use `http://host.docker.internal:11434`
-   - **Linux:** Use `http://<private_ip_of_host>:11434`
+The application uses Supabase for caching search results. Cache entries expire after 7 days.
 
-   Adjust the port number if you're using a different one.
+### Manual Cache Cleanup
 
-3. **Linux Users - Expose Ollama to Network:**
+If automatic cleanup is not available, you can manually clean up expired entries:
 
-   - Inside `/etc/systemd/system/ollama.service`, you need to add `Environment="OLLAMA_HOST=0.0.0.0"`. Then restart Ollama by `systemctl restart ollama`. For more information see [Ollama docs](https://github.com/ollama/ollama/blob/main/docs/faq.md#setting-environment-variables-on-linux)
+1. Using the API:
+```bash
+curl -X POST http://localhost:3000/api/cleanup
+```
 
-   - Ensure that the port (default is 11434) is not blocked by your firewall.
+2. Using SQL:
+```sql
+select manual_cleanup();
+```
 
-## Using as a Search Engine
+### Cache Statistics
 
-If you wish to use Perplexica as an alternative to traditional search engines like Google or Bing, or if you want to add a shortcut for quick access from your browser's search bar, follow these steps:
-
-1. Open your browser's settings.
-2. Navigate to the 'Search Engines' section.
-3. Add a new site search with the following URL: `http://localhost:3000/?q=%s`. Replace `localhost` with your IP address or domain name, and `3000` with the port number if Perplexica is not hosted locally.
-4. Click the add button. Now, you can use Perplexica directly from your browser's search bar.
-
-## Using Perplexica's API
-
-Perplexica also provides an API for developers looking to integrate its powerful search engine into their own applications. You can run searches, use multiple models and get answers to your queries.
-
-For more details, check out the full documentation [here](https://github.com/ItzCrazyKns/Perplexica/tree/master/docs/API/SEARCH.md).
-
-## Expose Perplexica to network
-
-Perplexica runs on Next.js and handles all API requests. It works right away on the same network and stays accessible even with port forwarding.
-
-## 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
-
-- [x] Add settings page
-- [x] Adding support for local LLMs
-- [x] History Saving features
-- [x] Introducing various Focus Modes
-- [x] Adding API support
-- [x] Adding Discover
-- [ ] Finalizing Copilot Mode
-
-## Support Us
-
-If you find Perplexica useful, consider giving us a star on GitHub. This helps more people discover Perplexica and supports the development of new features. Your support is greatly appreciated.
-
-### Donations
-
-We also accept donations to help sustain our project. If you would like to contribute, you can use the following options to donate. Thank you for your support!
-
-| Ethereum                                              |
-| ----------------------------------------------------- |
-| Address: `0xB025a84b2F269570Eb8D4b05DEdaA41D8525B6DD` |
-
-## Contribution
-
-Perplexica is built on the idea that AI and large language models should be easy for everyone to use. If you find bugs or have ideas, please share them in via GitHub Issues. For more information on contributing to Perplexica you can read the [CONTRIBUTING.md](CONTRIBUTING.md) file to learn more about Perplexica and how you can contribute to it.
-
-## Help and Support
-
-If you have any questions or feedback, please feel free to reach out to us. You can create an issue on GitHub or join our Discord server. There, you can connect with other users, share your experiences and reviews, and receive more personalized help. [Click here](https://discord.gg/EFwsmQDgAu) to join the Discord server. To discuss matters outside of regular support, feel free to contact me on Discord at `itzcrazykns`.
-
-Thank you for exploring Perplexica, the AI-powered search engine designed to enhance your search experience. We are constantly working to improve Perplexica and expand its capabilities. We value your feedback and contributions which help us make Perplexica even better. Don't forget to check back for updates and new features!
+View cache statistics using:
+```sql
+select * from cache_stats;
+```

app.dockerfile

@@ -1,27 +1,15 @@
-FROM node:20.18.0-slim AS builder
+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 package.json yarn.lock ./
-RUN yarn install --frozen-lockfile --network-timeout 600000
+COPY ui /home/perplexica/
 
-COPY tsconfig.json next.config.mjs next-env.d.ts postcss.config.js drizzle.config.ts tailwind.config.ts ./
-COPY src ./src
-COPY public ./public
-
-RUN mkdir -p /home/perplexica/data
+RUN yarn install --frozen-lockfile
 RUN yarn build
 
-FROM node:20.18.0-slim
-
-WORKDIR /home/perplexica
-
-COPY --from=builder /home/perplexica/public ./public
-COPY --from=builder /home/perplexica/.next/static ./public/_next/static
-
-COPY --from=builder /home/perplexica/.next/standalone ./
-COPY --from=builder /home/perplexica/data ./data
-
-RUN mkdir /home/perplexica/uploads
-
-CMD ["node", "server.js"]
+CMD ["yarn", "start"]

backend.dockerfile

@@ -0,0 +1,17 @@
+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"]

config.toml

@@ -0,0 +1,14 @@
+[GENERAL]
+PORT = 3001 # Port to run the server on
+SIMILARITY_MEASURE = "cosine" # "cosine" or "dot"
+KEEP_ALIVE = "5m" # How long to keep Ollama models loaded into memory. (Instead of using -1 use "-1m")
+
+[API_KEYS]
+OPENAI = "" # OpenAI API key - sk-1234567890abcdef1234567890abcdef
+GROQ = "" # Groq API key - gsk_1234567890abcdef1234567890abcdef
+ANTHROPIC = "" # Anthropic API key - sk-ant-1234567890abcdef1234567890abcdef
+GEMINI = "" # Gemini API key - sk-1234567890abcdef1234567890abcdef
+
+[API_ENDPOINTS]
+SEARXNG = "http://localhost:32768" # SearxNG API URL
+OLLAMA = "" # Ollama API URL - http://host.docker.internal:11434

db/init.sql

@@ -0,0 +1,189 @@
+-- Enable required extensions
+create extension if not exists "uuid-ossp";      -- For UUID generation
+create extension if not exists pg_cron;          -- For scheduled jobs
+
+-- Create the search_cache table
+create table public.search_cache (
+  id uuid default uuid_generate_v4() primary key,
+  query text not null,
+  results jsonb not null,
+  location text not null,
+  category text not null,
+  created_at timestamp with time zone default timezone('utc'::text, now()) not null,
+  updated_at timestamp with time zone default timezone('utc'::text, now()) not null,
+  expires_at timestamp with time zone default timezone('utc'::text, now() + interval '7 days') not null
+);
+
+-- Create indexes
+create index search_cache_query_idx on public.search_cache (query);
+create index search_cache_location_category_idx on public.search_cache (location, category);
+create index search_cache_expires_at_idx on public.search_cache (expires_at);
+
+-- Enable RLS
+alter table public.search_cache enable row level security;
+
+-- Create policies
+create policy "Allow public read access"
+  on public.search_cache for select
+  using (true);
+
+create policy "Allow service write access"
+  on public.search_cache for insert
+  with check (true);
+
+create policy "Allow service update access"
+  on public.search_cache for update
+  using (true)
+  with check (true);
+
+create policy "Allow delete expired records"
+  on public.search_cache for delete
+  using (expires_at < now());
+
+-- Create function to clean up expired records
+create or replace function cleanup_expired_cache()
+returns void
+language plpgsql
+security definer
+as $$
+begin
+  delete from public.search_cache
+  where expires_at < now();
+end;
+$$;
+
+-- Create a manual cleanup function since pg_cron might not be available
+create or replace function manual_cleanup()
+returns void
+language plpgsql
+security definer
+as $$
+begin
+  delete from public.search_cache
+  where expires_at < now();
+end;
+$$;
+
+-- Create a view for cache statistics
+create or replace view cache_stats as
+select
+  count(*) as total_entries,
+  count(*) filter (where expires_at < now()) as expired_entries,
+  count(*) filter (where expires_at >= now()) as valid_entries,
+  min(created_at) as oldest_entry,
+  max(created_at) as newest_entry,
+  count(distinct category) as unique_categories,
+  count(distinct location) as unique_locations
+from public.search_cache;
+
+-- Grant permissions to access the view
+grant select on cache_stats to postgres;
+
+-- Create table if not exists businesses
+create table if not exists businesses (
+  id text primary key,
+  name text not null,
+  phone text,
+  email text,
+  address text,
+  rating numeric,
+  website text,
+  logo text,
+  source text,
+  description text,
+  latitude numeric,
+  longitude numeric,
+  last_updated timestamp with time zone default timezone('utc'::text, now()),
+  search_count integer default 1,
+  created_at timestamp with time zone default timezone('utc'::text, now())
+);
+
+-- Create indexes for common queries
+create index if not exists businesses_name_idx on businesses (name);
+create index if not exists businesses_rating_idx on businesses (rating desc);
+create index if not exists businesses_search_count_idx on businesses (search_count desc);
+create index if not exists businesses_last_updated_idx on businesses (last_updated desc);
+
+-- Create tables if they don't exist
+CREATE TABLE IF NOT EXISTS businesses (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    phone TEXT,
+    email TEXT,
+    address TEXT,
+    rating INTEGER,
+    website TEXT,
+    logo TEXT,
+    source TEXT,
+    description TEXT,
+    location JSONB,
+    place_id TEXT,
+    photos TEXT[],
+    opening_hours TEXT[],
+    distance JSONB,
+    last_updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    search_count INTEGER DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS searches (
+    id SERIAL PRIMARY KEY,
+    query TEXT NOT NULL,
+    location TEXT NOT NULL,
+    timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    results_count INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS cache (
+    key TEXT PRIMARY KEY,
+    value JSONB NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    expires_at TIMESTAMP WITH TIME ZONE NOT NULL
+);
+
+-- Create indexes
+CREATE INDEX IF NOT EXISTS idx_businesses_location ON businesses USING GIN (location);
+CREATE INDEX IF NOT EXISTS idx_businesses_search ON businesses USING GIN (to_tsvector('english', name || ' ' || COALESCE(description, '')));
+CREATE INDEX IF NOT EXISTS idx_cache_expires ON cache (expires_at);
+
+-- Set up RLS (Row Level Security)
+ALTER TABLE businesses ENABLE ROW LEVEL SECURITY;
+ALTER TABLE searches ENABLE ROW LEVEL SECURITY;
+ALTER TABLE cache ENABLE ROW LEVEL SECURITY;
+
+-- Create policies
+CREATE POLICY "Allow anonymous select" ON businesses FOR SELECT USING (true);
+CREATE POLICY "Allow service role insert" ON businesses FOR INSERT WITH CHECK (true);
+CREATE POLICY "Allow service role update" ON businesses FOR UPDATE USING (true);
+
+CREATE POLICY "Allow anonymous select" ON searches FOR SELECT USING (true);
+CREATE POLICY "Allow service role insert" ON searches FOR INSERT WITH CHECK (true);
+
+CREATE POLICY "Allow anonymous select" ON cache FOR SELECT USING (true);
+CREATE POLICY "Allow service role all" ON cache USING (true);
+
+-- Add place_id column to businesses table if it doesn't exist
+ALTER TABLE businesses ADD COLUMN IF NOT EXISTS place_id TEXT;
+CREATE INDEX IF NOT EXISTS idx_businesses_place_id ON businesses(place_id);
+
+-- Create a unique constraint on place_id (excluding nulls)
+CREATE UNIQUE INDEX IF NOT EXISTS idx_businesses_place_id_unique 
+ON businesses(place_id) 
+WHERE place_id IS NOT NULL; 
+
+CREATE TABLE IF NOT EXISTS businesses (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    address TEXT NOT NULL,
+    phone TEXT NOT NULL,
+    description TEXT NOT NULL,
+    website TEXT,
+    source TEXT NOT NULL,
+    rating REAL,
+    lat REAL,
+    lng REAL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_businesses_source ON businesses(source);
+CREATE INDEX IF NOT EXISTS idx_businesses_rating ON businesses(rating); 

db/schema.sql

@@ -0,0 +1,44 @@
+-- Create the businesses table
+create table businesses (
+  id uuid primary key,
+  name text not null,
+  phone text,
+  address text,
+  city text,
+  state text,
+  zip text,
+  category text[],
+  rating numeric,
+  review_count integer,
+  license text,
+  services text[],
+  hours jsonb,
+  website text,
+  email text,
+  verified boolean default false,
+  last_updated timestamp with time zone,
+  search_query text,
+  search_location text,
+  search_timestamp timestamp with time zone,
+  reliability_score integer,
+  
+  -- Create a composite index for deduplication
+  constraint unique_business unique (phone, address)
+);
+
+-- Create indexes for common queries
+create index idx_business_location on businesses (city, state);
+create index idx_business_category on businesses using gin (category);
+create index idx_search_query on businesses using gin (search_query gin_trgm_ops);
+create index idx_search_location on businesses using gin (search_location gin_trgm_ops);
+create index idx_reliability on businesses (reliability_score);
+
+-- Enable full text search
+alter table businesses add column search_vector tsvector 
+  generated always as (
+    setweight(to_tsvector('english', coalesce(name, '')), 'A') ||
+    setweight(to_tsvector('english', coalesce(search_query, '')), 'B') ||
+    setweight(to_tsvector('english', coalesce(search_location, '')), 'C')
+  ) stored;
+
+create index idx_business_search on businesses using gin(search_vector); 

db/verify.sql

@@ -0,0 +1,15 @@
+-- Check if table exists
+SELECT EXISTS (
+   SELECT FROM information_schema.tables 
+   WHERE table_schema = 'public'
+   AND table_name = 'businesses'
+);
+
+-- Check table structure
+SELECT column_name, data_type, is_nullable
+FROM information_schema.columns
+WHERE table_schema = 'public'
+AND table_name = 'businesses';
+
+-- Check row count
+SELECT COUNT(*) as count FROM businesses; 

docker-compose.yaml

@@ -9,21 +9,41 @@ services:
       - perplexica-network
     restart: unless-stopped
 
-  app:
-    image: itzcrazykns1337/perplexica:main
+  perplexica-backend:
     build:
       context: .
-      dockerfile: app.dockerfile
+      dockerfile: backend.dockerfile
+    image: itzcrazykns1337/perplexica-backend:main
     environment:
       - SEARXNG_API_URL=http://searxng:8080
+    depends_on:
+      - searxng
     ports:
-      - 3000:3000
-    networks:
-      - perplexica-network
+      - 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:
+    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
+    ports:
+      - 3000:3000
+    networks:
+      - perplexica-network
     restart: unless-stopped
 
 networks:

docker-compose.yml

@@ -0,0 +1,26 @@
+version: '3'
+services:
+  searxng:
+    image: searxng/searxng
+    ports:
+      - "4000:8080"
+    volumes:
+      - ./searxng:/etc/searxng
+    environment:
+      - INSTANCE_NAME=perplexica-searxng
+      - BASE_URL=http://localhost:4000/
+      - SEARXNG_SECRET=your_secret_key_here
+    restart: unless-stopped
+
+  app:
+    build:
+      context: .
+      dockerfile: backend.dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - SEARXNG_URL=http://searxng:8080
+    volumes:
+      - ./config.toml:/home/perplexica/config.toml
+    depends_on:
+      - searxng 

docs/API/SEARCH.md

@@ -6,9 +6,9 @@ Perplexica’s Search API makes it easy to use our AI-powered search engine. You
 
 ## Endpoint
 
-### **POST** `http://localhost:3000/api/search`
+### **POST** `http://localhost:3001/api/search`
 
-**Note**: Replace `3000` with any other port if you've changed the default PORT
+**Note**: Replace `3001` with any other port if you've changed the default PORT
 
 ### Request
 
@@ -20,11 +20,11 @@ The API accepts a JSON object in the request body, where you define the focus mo
 {
   "chatModel": {
     "provider": "openai",
-    "name": "gpt-4o-mini"
+    "model": "gpt-4o-mini"
   },
   "embeddingModel": {
     "provider": "openai",
-    "name": "text-embedding-3-large"
+    "model": "text-embedding-3-large"
   },
   "optimizationMode": "speed",
   "focusMode": "webSearch",
@@ -32,25 +32,24 @@ The API accepts a JSON object in the request body, where you define the focus mo
   "history": [
     ["human", "Hi, how are you?"],
     ["assistant", "I am doing well, how can I help you today?"]
-  ],
-  "stream": false
+  ]
 }
 ```
 
 ### Request Parameters
 
-- **`chatModel`** (object, optional): Defines the chat model to be used for the query. For model details you can send a GET request at `http://localhost:3000/api/models`. Make sure to use the key value (For example "gpt-4o-mini" instead of the display name "GPT 4 omni mini").
+- **`chatModel`** (object, optional): Defines the chat model to be used for the query. For model details you can send a GET request at `http://localhost:3001/api/models`. Make sure to use the key value (For example "gpt-4o-mini" instead of the display name "GPT 4 omni mini").
 
   - `provider`: Specifies the provider for the chat model (e.g., `openai`, `ollama`).
-  - `name`: The specific model from the chosen provider (e.g., `gpt-4o-mini`).
+  - `model`: The specific model from the chosen provider (e.g., `gpt-4o-mini`).
   - Optional fields for custom OpenAI configuration:
     - `customOpenAIBaseURL`: If you’re using a custom OpenAI instance, provide the base URL.
     - `customOpenAIKey`: The API key for a custom OpenAI instance.
 
-- **`embeddingModel`** (object, optional): Defines the embedding model for similarity-based searching. For model details you can send a GET request at `http://localhost:3000/api/models`. Make sure to use the key value (For example "text-embedding-3-large" instead of the display name "Text Embedding 3 Large").
+- **`embeddingModel`** (object, optional): Defines the embedding model for similarity-based searching. For model details you can send a GET request at `http://localhost:3001/api/models`. Make sure to use the key value (For example "text-embedding-3-large" instead of the display name "Text Embedding 3 Large").
 
   - `provider`: The provider for the embedding model (e.g., `openai`).
-  - `name`: The specific embedding model (e.g., `text-embedding-3-large`).
+  - `model`: The specific embedding model (e.g., `text-embedding-3-large`).
 
 - **`focusMode`** (string, required): Specifies which focus mode to use. Available modes:
 
@@ -72,13 +71,11 @@ The API accepts a JSON object in the request body, where you define the focus mo
   ]
   ```
 
-- **`stream`** (boolean, optional): When set to `true`, enables streaming responses. Default is `false`.
-
 ### Response
 
 The response from the API includes both the final message and the sources used to generate that message.
 
-#### Standard Response (stream: false)
+#### Example Response
 
 ```json
 {
@@ -103,28 +100,6 @@ The response from the API includes both the final message and the sources used t
 }
 ```
 
-#### Streaming Response (stream: true)
-
-When streaming is enabled, the API returns a stream of newline-delimited JSON objects. Each line contains a complete, valid JSON object. The response has Content-Type: application/json.
-
-Example of streamed response objects:
-
-```
-{"type":"init","data":"Stream connected"}
-{"type":"sources","data":[{"pageContent":"...","metadata":{"title":"...","url":"..."}},...]}
-{"type":"response","data":"Perplexica is an "}
-{"type":"response","data":"innovative, open-source "}
-{"type":"response","data":"AI-powered search engine..."}
-{"type":"done"}
-```
-
-Clients should process each line as a separate JSON object. The different message types include:
-
-- **`init`**: Initial connection message
-- **`sources`**: All sources used for the response
-- **`response`**: Chunks of the generated answer text
-- **`done`**: Indicates the stream is complete
-
 ### Fields in the Response
 
 - **`message`** (string): The search result, generated based on the query and focus mode.

docs/ETHICAL_SCRAPING.md

@@ -0,0 +1,108 @@
+# Ethical Web Scraping Guidelines
+
+## Core Principles
+
+1. **Respect Robots.txt**
+   - Always check and honor robots.txt directives
+   - Cache robots.txt to reduce server load
+   - Default to conservative behavior when uncertain
+
+2. **Proper Identification**
+   - Use clear, identifiable User-Agent strings
+   - Provide contact information
+   - Be transparent about your purpose
+
+3. **Rate Limiting**
+   - Implement conservative rate limits
+   - Use exponential backoff for errors
+   - Distribute requests over time
+
+4. **Data Usage**
+   - Only collect publicly available business information
+   - Respect privacy and data protection laws
+   - Provide clear opt-out mechanisms
+   - Keep data accurate and up-to-date
+
+5. **Technical Considerations**
+   - Cache results to minimize requests
+   - Handle errors gracefully
+   - Monitor and log access patterns
+   - Use structured data when available
+
+## Implementation
+
+1. **Request Headers**
+```typescript
+const headers = {
+  'User-Agent': 'BizSearch/1.0 (+https://bizsearch.com/about)',
+  'Accept': 'text/html,application/xhtml+xml',
+  'From': 'contact@bizsearch.com'
+};
+```
+
+2. **Rate Limiting**
+```typescript
+const rateLimits = {
+  requestsPerMinute: 10,
+  requestsPerHour: 100,
+  requestsPerDomain: 20
+};
+```
+
+3. **Caching**
+```typescript
+const cacheSettings = {
+  ttl: 24 * 60 * 60, // 24 hours
+  maxSize: 1000 // entries
+};
+```
+
+## Opt-Out Process
+
+1. Business owners can opt-out by:
+   - Submitting a form on our website
+   - Emailing opt-out@bizsearch.com
+   - Adding a meta tag: `<meta name="bizsearch" content="noindex">`
+
+2. We honor opt-outs within:
+   - 24 hours for direct requests
+   - 72 hours for cached data
+
+## Legal Compliance
+
+1. **Data Protection**
+   - GDPR compliance for EU businesses
+   - CCPA compliance for California businesses
+   - Regular data audits and cleanup
+
+2. **Attribution**
+   - Clear source attribution
+   - Last-updated timestamps
+   - Data accuracy disclaimers
+
+## Best Practices
+
+1. **Before Scraping**
+   - Check robots.txt
+   - Verify site status
+   - Review terms of service
+   - Look for API alternatives
+
+2. **During Scraping**
+   - Monitor response codes
+   - Respect server hints
+   - Implement backoff strategies
+   - Log access patterns
+
+3. **After Scraping**
+   - Verify data accuracy
+   - Update cache entries
+   - Clean up old data
+   - Monitor opt-out requests
+
+## Contact
+
+For questions or concerns about our scraping practices:
+- Email: ethics@bizsearch.com
+- Phone: (555) 123-4567
+- Web: https://bizsearch.com/ethics 

docs/architecture/WORKING.md

@@ -4,7 +4,7 @@ Curious about how Perplexica works? Don't worry, we'll cover it here. Before we
 
 We'll understand how Perplexica works by taking an example of a scenario where a user asks: "How does an A.C. work?". We'll break down the process into steps to make it easier to understand. The steps are as follows:
 
-1. The message is sent to the `/api/chat` route where it invokes the chain. The chain will depend on your focus mode. For this example, let's assume we use the "webSearch" focus mode.
+1. The message is sent via WS to the backend server where it invokes the chain. The chain will depend on your focus mode. For this example, let's assume we use the "webSearch" focus mode.
 2. The chain is now invoked; first, the message is passed to another chain where it first predicts (using the chat history and the question) whether there is a need for sources and searching the web. If there is, it will generate a query (in accordance with the chat history) for searching the web that we'll take up later. If not, the chain will end there, and then the answer generator chain, also known as the response generator, will be started.
 3. The query returned by the first chain is passed to SearXNG to search the web for information.
 4. After the information is retrieved, it is based on keyword-based search. We then convert the information into embeddings and the query as well, then we perform a similarity search to find the most relevant sources to answer the query.

docs/installation/NETWORKING.md

@@ -0,0 +1,109 @@
+# Expose Perplexica to a network
+
+This guide will show you how to make Perplexica available over a network. Follow these steps to allow computers on the same network to interact with Perplexica. Choose the instructions that match the operating system you are using.
+
+## Windows
+
+1. Open PowerShell as Administrator
+
+2. Navigate to the directory containing the `docker-compose.yaml` file
+
+3. Stop and remove the existing Perplexica containers and images:
+
+   ```bash
+   docker compose down --rmi all
+   ```
+
+4. Open the `docker-compose.yaml` file in a text editor like Notepad++
+
+5. Replace `127.0.0.1` with the IP address of the server Perplexica is running on in these two lines:
+
+   ```bash
+   args:
+     - NEXT_PUBLIC_API_URL=http://127.0.0.1:3001/api
+     - NEXT_PUBLIC_WS_URL=ws://127.0.0.1:3001
+   ```
+
+6. Save and close the `docker-compose.yaml` file
+
+7. Rebuild and restart the Perplexica container:
+
+   ```bash
+   docker compose up -d --build
+   ```
+
+## macOS
+
+1. Open the Terminal application
+
+2. Navigate to the directory with the `docker-compose.yaml` file:
+
+   ```bash
+   cd /path/to/docker-compose.yaml
+   ```
+
+3. Stop and remove existing containers and images:
+
+   ```bash
+   docker compose down --rmi all
+   ```
+
+4. Open `docker-compose.yaml` in a text editor like Sublime Text:
+
+   ```bash
+   nano docker-compose.yaml
+   ```
+
+5. Replace `127.0.0.1` with the server IP in these lines:
+
+   ```bash
+   args:
+     - NEXT_PUBLIC_API_URL=http://127.0.0.1:3001/api
+     - NEXT_PUBLIC_WS_URL=ws://127.0.0.1:3001
+   ```
+
+6. Save and exit the editor
+
+7. Rebuild and restart Perplexica:
+
+   ```bash
+   docker compose up -d --build
+   ```
+
+## Linux
+
+1. Open the terminal
+
+2. Navigate to the `docker-compose.yaml` directory:
+
+   ```bash
+   cd /path/to/docker-compose.yaml
+   ```
+
+3. Stop and remove containers and images:
+
+   ```bash
+   docker compose down --rmi all
+   ```
+
+4. Edit `docker-compose.yaml`:
+
+   ```bash
+   nano docker-compose.yaml
+   ```
+
+5. Replace `127.0.0.1` with the server IP:
+
+   ```bash
+   args:
+     - NEXT_PUBLIC_API_URL=http://127.0.0.1:3001/api
+     - NEXT_PUBLIC_WS_URL=ws://127.0.0.1:3001
+   ```
+
+6. Save and exit the editor
+
+7. Rebuild and restart Perplexica:
+
+   ```bash
+   docker compose up -d --build
+   ```

docs/installation/UPDATING.md

@@ -7,40 +7,34 @@ 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. 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.
+3. Pull latest images from registry.
 
    ```bash
    docker compose pull
    ```
 
-5. Update and recreate the containers.
+4. Update and Recreate containers.
 
    ```bash
    docker compose up -d
    ```
 
-6. Once the command completes, go to http://localhost:3000 and verify the latest changes.
+5. Once the command completes running 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. 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. After populating the configuration run `npm i`.
-5. Install the dependencies and then execute `npm run build`.
-6. Finally, start the app by running `npm rum start`
-
----
+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.

drizzle.config.ts

@@ -2,7 +2,7 @@ import { defineConfig } from 'drizzle-kit';
 
 export default defineConfig({
   dialect: 'sqlite',
-  schema: './src/lib/db/schema.ts',
+  schema: './src/db/schema.ts',
   out: './drizzle',
   dbCredentials: {
     url: './data/db.sqlite',

frontend/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

frontend/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

frontend/eslint.config.mjs

@@ -0,0 +1,16 @@
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+const eslintConfig = [
+  ...compat.extends("next/core-web-vitals", "next/typescript"),
+];
+
+export default eslintConfig;

frontend/next.config.js

@@ -0,0 +1,13 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  async rewrites() {
+    return [
+      {
+        source: '/api/:path*',
+        destination: 'http://localhost:3000/api/:path*',
+      },
+    ]
+  }
+}
+
+module.exports = nextConfig 

frontend/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;

frontend/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "frontend",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@radix-ui/react-icons": "^1.3.2",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.469.0",
+    "next": "15.1.3",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwind-merge": "^2.6.0",
+    "tailwindcss-animate": "^1.0.7"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "15.1.3",
+    "postcss": "^8",
+    "tailwindcss": "^3.4.1",
+    "typescript": "^5"
+  }
+}

frontend/postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    tailwindcss: {},
+  },
+};
+
+export default config;

frontend/public/file.svg

@@ -0,0 +1 @@
+<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>

frontend/public/globe.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>

frontend/public/vercel.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>

frontend/public/window.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 2.5h13v10a1 1 0 0 1-1 1h-11a1 1 0 0 1-1-1zM0 1h16v11.5a2.5 2.5 0 0 1-2.5 2.5h-11A2.5 2.5 0 0 1 0 12.5zm3.75 4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5M7 4.75a.75.75 0 1 1-1.5 0 .75.75 0 0 1 1.5 0m1.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5" fill="#666"/></svg>

frontend/src/app/globals.css

@@ -0,0 +1,76 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+ 
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+ 
+    --primary: 222.2 47.4% 11.2%;
+    --primary-foreground: 210 40% 98%;
+ 
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+ 
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+ 
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+ 
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 222.2 84% 4.9%;
+ 
+    --radius: 0.5rem;
+  }
+ 
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+ 
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+ 
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+ 
+    --primary: 210 40% 98%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+ 
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+ 
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+ 
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+ 
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+ 
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 212.7 26.8% 83.9%;
+  }
+}
+ 
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}

frontend/src/app/layout.tsx

@@ -0,0 +1,34 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "Create Next App",
+  description: "Generated by create next app",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}

frontend/src/app/page.tsx

@@ -0,0 +1,26 @@
+'use client'
+
+import { ServerStatus } from "@/components/server-status"
+import { SearchForm } from "@/components/search-form"
+import { SearchResults } from "@/components/search-results"
+import { useState } from "react"
+
+export default function Home() {
+  const [searchResults, setSearchResults] = useState([])
+  const [isSearching, setIsSearching] = useState(false)
+
+  const services = [
+    { name: "Ollama", status: "running" as const },
+    { name: "SearxNG", status: "running" as const },
+    { name: "Supabase", status: "running" as const }
+  ]
+
+  return (
+    <main className="container mx-auto p-4">
+      <h1 className="text-4xl font-bold text-center mb-8">Business Search</h1>
+      <SearchForm onSearch={setSearchResults} onSearchingChange={setIsSearching} />
+      <SearchResults results={searchResults} isLoading={isSearching} />
+      <ServerStatus services={services} />
+    </main>
+  )
+}

frontend/src/components/search-form.tsx

@@ -0,0 +1,79 @@
+import { Search } from "lucide-react"
+import { useState } from "react"
+
+interface SearchFormProps {
+  onSearch: (results: any[]) => void;
+  onSearchingChange: (isSearching: boolean) => void;
+}
+
+export function SearchForm({ onSearch, onSearchingChange }: SearchFormProps) {
+  const [query, setQuery] = useState("")
+  const [error, setError] = useState<string | null>(null)
+
+  const handleSearch = async (e: React.FormEvent) => {
+    e.preventDefault()
+    if (!query.trim()) return
+
+    setError(null)
+    onSearchingChange(true)
+    try {
+      const response = await fetch("/api/search", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ query: query.trim() }),
+      })
+
+      if (!response.ok) {
+        throw new Error("Search failed")
+      }
+
+      const data = await response.json()
+      onSearch(data.results || [])
+      
+    } catch (error) {
+      console.error("Search error:", error)
+      onSearch([])
+      setError("Failed to perform search. Please try again.")
+    } finally {
+      onSearchingChange(false)
+    }
+  }
+
+  return (
+    <div className="w-full max-w-2xl mx-auto mt-8 mb-12">
+      <div className="flex flex-col gap-4">
+        <div className="flex flex-col gap-2">
+          <label htmlFor="search" className="text-lg font-medium text-center">
+            Find local businesses
+          </label>
+          <form onSubmit={handleSearch} className="relative">
+            <input
+              id="search"
+              type="text"
+              value={query}
+              onChange={(e) => setQuery(e.target.value)}
+              placeholder="e.g. plumbers in Denver, CO"
+              className="w-full px-4 py-3 text-lg rounded-lg border border-border bg-background focus:outline-none focus:ring-2 focus:ring-primary"
+            />
+            <button 
+              type="submit"
+              disabled={!query.trim()}
+              className="absolute right-2 top-1/2 -translate-y-1/2 p-3 rounded-md bg-primary text-primary-foreground hover:bg-primary/90 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+              aria-label="Search"
+            >
+              <Search className="h-5 w-5" />
+            </button>
+          </form>
+          {error && (
+            <p className="text-sm text-destructive text-center">{error}</p>
+          )}
+          <p className="text-sm text-muted-foreground text-center mt-2">
+            Try searching for: restaurants, dentists, electricians, etc.
+          </p>
+        </div>
+      </div>
+    </div>
+  )
+} 

frontend/src/components/search-results.tsx

@@ -0,0 +1,76 @@
+interface Business {
+  id: string;
+  name: string;
+  address: string;
+  phone: string;
+  website?: string;
+  email?: string;
+  description?: string;
+  rating?: number;
+}
+
+interface SearchResultsProps {
+  results: Business[];
+  isLoading: boolean;
+}
+
+export function SearchResults({ results, isLoading }: SearchResultsProps) {
+  if (isLoading) {
+    return (
+      <div className="w-full max-w-4xl mx-auto mt-8">
+        <div className="animate-pulse space-y-4">
+          {[...Array(3)].map((_, i) => (
+            <div key={i} className="bg-muted rounded-lg p-6">
+              <div className="h-4 bg-muted-foreground/20 rounded w-3/4 mb-4"></div>
+              <div className="h-3 bg-muted-foreground/20 rounded w-1/2"></div>
+            </div>
+          ))}
+        </div>
+      </div>
+    )
+  }
+
+  if (!results.length) {
+    return null
+  }
+
+  return (
+    <div className="w-full max-w-4xl mx-auto mt-8">
+      <div className="space-y-4">
+        {results.map((business) => (
+          <div key={business.id} className="bg-card rounded-lg p-6 shadow-sm">
+            <h3 className="text-xl font-semibold mb-2">{business.name}</h3>
+            {business.address && (
+              <p className="text-muted-foreground mb-2">{business.address}</p>
+            )}
+            <div className="flex flex-wrap gap-4 text-sm">
+              {business.phone && (
+                <a 
+                  href={`tel:${business.phone}`}
+                  className="text-primary hover:underline"
+                >
+                  {business.phone}
+                </a>
+              )}
+              {business.website && (
+                <a 
+                  href={business.website}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="text-primary hover:underline"
+                >
+                  Visit Website
+                </a>
+              )}
+            </div>
+            {business.description && (
+              <p className="mt-4 text-sm text-muted-foreground">
+                {business.description}
+              </p>
+            )}
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+} 

frontend/src/components/server-status.tsx

@@ -0,0 +1,59 @@
+import { CheckCircle2, XCircle, AlertCircle } from "lucide-react"
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert"
+
+interface ServiceStatus {
+  name: string
+  status: "running" | "error" | "warning"
+}
+
+interface ServerStatusProps {
+  services: ServiceStatus[]
+  error?: string
+}
+
+export function ServerStatus({ services, error }: ServerStatusProps) {
+  if (error) {
+    return (
+      <Alert variant="destructive" className="max-w-md mx-auto mt-4">
+        <XCircle className="h-4 w-4" />
+        <AlertTitle>Server Error</AlertTitle>
+        <AlertDescription>{error}</AlertDescription>
+      </Alert>
+    )
+  }
+
+  return (
+    <div className="space-y-4 max-w-md mx-auto mt-4">
+      <h2 className="text-xl font-semibold text-center mb-6">Service Status</h2>
+      <div className="space-y-3">
+        {services.map((service) => (
+          <Alert 
+            key={service.name}
+            variant={service.status === "error" ? "destructive" : "default"}
+            className="flex items-center justify-between hover:bg-accent/50 transition-colors"
+          >
+            <div className="flex items-center gap-3">
+              {service.status === "running" && (
+                <CheckCircle2 className="h-5 w-5 text-green-500 shrink-0" />
+              )}
+              {service.status === "error" && (
+                <XCircle className="h-5 w-5 text-red-500 shrink-0" />
+              )}
+              {service.status === "warning" && (
+                <AlertCircle className="h-5 w-5 text-yellow-500 shrink-0" />
+              )}
+              <AlertTitle className="font-medium">{service.name}</AlertTitle>
+            </div>
+            <span className={`text-sm ${
+              service.status === "running" ? "text-green-600" :
+              service.status === "error" ? "text-red-600" :
+              "text-yellow-600"
+            }`}>
+              {service.status.charAt(0).toUpperCase() + service.status.slice(1)}
+            </span>
+          </Alert>
+        ))}
+      </div>
+    </div>
+  )
+} 

frontend/src/components/ui/alert.tsx

@@ -0,0 +1,58 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+import { cn } from "@/lib/utils"
+
+const alertVariants = cva(
+  "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        destructive:
+          "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+const Alert = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
+>(({ className, variant, ...props }, ref) => (
+  <div
+    ref={ref}
+    role="alert"
+    className={cn(alertVariants({ variant }), className)}
+    {...props}
+  />
+))
+Alert.displayName = "Alert"
+
+const AlertTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h5
+    ref={ref}
+    className={cn("mb-1 font-medium leading-none tracking-tight", className)}
+    {...props}
+  />
+))
+AlertTitle.displayName = "AlertTitle"
+
+const AlertDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("text-sm [&_p]:leading-relaxed", className)}
+    {...props}
+  />
+))
+AlertDescription.displayName = "AlertDescription"
+
+export { Alert, AlertTitle, AlertDescription } 

frontend/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+} 

frontend/tailwind.config.ts

@@ -0,0 +1,79 @@
+import type { Config } from "tailwindcss";
+
+const config: Config = {
+  darkMode: ["class"],
+  content: [
+    './pages/**/*.{ts,tsx}',
+    './components/**/*.{ts,tsx}',
+    './app/**/*.{ts,tsx}',
+    './src/**/*.{ts,tsx}',
+  ],
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      keyframes: {
+        "accordion-down": {
+          from: { height: "0" },
+          to: { height: "var(--radix-accordion-content-height)" },
+        },
+        "accordion-up": {
+          from: { height: "var(--radix-accordion-content-height)" },
+          to: { height: "0" },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate")],
+}
+
+export default config;

frontend/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

jest.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.{ts,js}',
+    '!src/tests/**',
+    '!**/node_modules/**',
+  ],
+  coverageDirectory: 'coverage',
+  setupFilesAfterEnv: ['<rootDir>/src/tests/setup.ts'],
+}; 

next-env.d.ts

@@ -1,5 +0,0 @@
-/// <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.

package.json

@@ -1,65 +1,80 @@
 {
-  "name": "perplexica-frontend",
-  "version": "1.10.1",
+  "name": "perplexica-backend",
+  "version": "1.10.0-rc2",
   "license": "MIT",
   "author": "ItzCrazyKns",
   "scripts": {
-    "dev": "next dev",
-    "build": "npm run db:push && next build",
-    "start": "next start",
-    "lint": "next lint",
+    "start": "ts-node src/index.ts",
+    "build": "tsc",
+    "dev": "nodemon src/index.ts",
+    "db:push": "drizzle-kit push sqlite",
+    "format": "prettier . --check",
     "format:write": "prettier . --write",
-    "db:push": "drizzle-kit push"
-  },
-  "dependencies": {
-    "@headlessui/react": "^2.2.0",
-    "@iarna/toml": "^2.2.5",
-    "@icons-pack/react-simple-icons": "^12.3.0",
-    "@langchain/anthropic": "^0.3.15",
-    "@langchain/community": "^0.3.36",
-    "@langchain/core": "^0.3.42",
-    "@langchain/google-genai": "^0.1.12",
-    "@langchain/openai": "^0.0.25",
-    "@langchain/textsplitters": "^0.1.0",
-    "@tailwindcss/typography": "^0.5.12",
-    "@xenova/transformers": "^2.17.2",
-    "axios": "^1.8.3",
-    "better-sqlite3": "^11.9.1",
-    "clsx": "^2.1.0",
-    "compute-cosine-similarity": "^1.1.0",
-    "compute-dot": "^1.1.0",
-    "drizzle-orm": "^0.40.1",
-    "html-to-text": "^9.0.5",
-    "langchain": "^0.1.30",
-    "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",
-    "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"
+    "test:search": "ts-node src/tests/testSearch.ts",
+    "test:supabase": "ts-node src/tests/supabaseTest.ts",
+    "test:deepseek": "ts-node src/tests/testDeepseek.ts",
+    "test:ollama": "ts-node src/tests/testOllama.ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "build:css": "tailwindcss -i ./src/styles/input.css -o ./public/styles/output.css",
+    "watch:css": "tailwindcss -i ./src/styles/input.css -o ./public/styles/output.css --watch"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.12",
+    "@testing-library/jest-dom": "^6.1.5",
+    "@types/better-sqlite3": "^7.6.10",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
     "@types/html-to-text": "^9.0.4",
-    "@types/node": "^20",
+    "@types/jest": "^29.5.11",
+    "@types/multer": "^1.4.12",
+    "@types/node-fetch": "^2.6.12",
     "@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",
+    "@types/readable-stream": "^4.0.11",
+    "@types/supertest": "^6.0.2",
+    "@types/ws": "^8.5.12",
+    "autoprefixer": "^10.4.20",
+    "drizzle-kit": "^0.22.7",
+    "jest": "^29.7.0",
+    "nodemon": "^3.1.0",
+    "postcss": "^8.4.49",
     "prettier": "^3.2.5",
-    "tailwindcss": "^3.3.0",
-    "typescript": "^5"
+    "supertest": "^7.0.0",
+    "tailwindcss": "^3.4.17",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.3"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "latest",
+    "@iarna/toml": "^2.2.5",
+    "@langchain/anthropic": "^0.2.3",
+    "@langchain/community": "^0.2.16",
+    "@langchain/google-genai": "^0.0.23",
+    "@langchain/openai": "^0.0.25",
+    "@shadcn/ui": "^0.0.4",
+    "@supabase/supabase-js": "^2.47.10",
+    "@xenova/transformers": "^2.17.1",
+    "axios": "^1.6.8",
+    "better-sqlite3": "^11.7.0",
+    "cheerio": "^1.0.0",
+    "compute-cosine-similarity": "^1.1.0",
+    "compute-dot": "^1.1.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "drizzle-orm": "^0.31.2",
+    "express": "^4.19.2",
+    "html-to-text": "^9.0.5",
+    "langchain": "^0.1.30",
+    "mammoth": "^1.8.0",
+    "multer": "^1.4.5-lts.1",
+    "node-fetch": "^2.7.0",
+    "pdf-parse": "^1.1.1",
+    "robots-parser": "^3.0.1",
+    "tesseract.js": "^4.1.4",
+    "torch": "latest",
+    "winston": "^3.13.0",
+    "ws": "^8.17.1",
+    "zod": "^3.24.1"
   }
 }

postcss.config.js

@@ -3,4 +3,4 @@ module.exports = {
     tailwindcss: {},
     autoprefixer: {},
   },
-};
+}

public/index.html

@@ -0,0 +1,214 @@
+<!DOCTYPE html>
+<html lang="en" class="h-full bg-gray-50">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OffMarket Pro - Business Search</title>
+    <link href="/styles/output.css" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+</head>
+<body class="min-h-full">
+    <div class="bg-white">
+        <!-- Navigation -->
+        <nav class="bg-white shadow-sm">
+            <div class="mx-auto max-w-7xl px-4 sm:px-6 lg:px-8">
+                <div class="flex h-16 justify-between items-center">
+                    <div class="flex-shrink-0 flex items-center">
+                        <h1 class="text-xl font-bold text-gray-900">OffMarket Pro</h1>
+                    </div>
+                </div>
+            </div>
+        </nav>
+
+        <!-- Main Content -->
+        <main class="mx-auto max-w-7xl px-4 sm:px-6 lg:px-8 py-8">
+            <!-- Search Form -->
+            <div class="mb-8">
+                <h2 class="text-2xl font-bold text-gray-900 mb-6">Find Off-Market Property Services</h2>
+                <div class="grid grid-cols-1 gap-4 sm:grid-cols-2">
+                    <div>
+                        <label for="searchQuery" class="block text-sm font-medium text-gray-700">Service Type</label>
+                        <input type="text" id="searchQuery" class="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-primary focus:ring-primary sm:text-sm" placeholder="e.g. plumber, electrician">
+                    </div>
+                    <div>
+                        <label for="searchLocation" class="block text-sm font-medium text-gray-700">Location</label>
+                        <input type="text" id="searchLocation" class="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-primary focus:ring-primary sm:text-sm" placeholder="e.g. Denver, CO">
+                    </div>
+                </div>
+                <div class="mt-4">
+                    <button onclick="performSearch()" class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-primary hover:bg-primary-hover focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-primary">
+                        Search
+                    </button>
+                </div>
+            </div>
+
+            <!-- Progress Indicator -->
+            <div id="searchProgress" class="hidden mb-8">
+                <div class="bg-white shadow sm:rounded-lg">
+                    <div class="px-4 py-5 sm:p-6">
+                        <h3 class="text-lg font-medium leading-6 text-gray-900">Search Progress</h3>
+                        <div class="mt-4">
+                            <div class="relative pt-1">
+                                <div class="overflow-hidden h-2 mb-4 text-xs flex rounded bg-gray-200">
+                                    <div id="progressBar" class="shadow-none flex flex-col text-center whitespace-nowrap text-white justify-center bg-primary transition-all duration-500" style="width: 0%"></div>
+                                </div>
+                                <div id="progressText" class="text-sm text-gray-600"></div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Error Display -->
+            <div id="errorDisplay" class="hidden mb-8">
+                <div class="rounded-md bg-red-50 p-4">
+                    <div class="flex">
+                        <div class="flex-shrink-0">
+                            <svg class="h-5 w-5 text-red-400" viewBox="0 0 20 20" fill="currentColor">
+                                <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd"/>
+                            </svg>
+                        </div>
+                        <div class="ml-3">
+                            <h3 class="text-sm font-medium text-red-800">Error</h3>
+                            <div class="mt-2 text-sm text-red-700">
+                                <p id="errorMessage"></p>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Results Table -->
+            <div id="resultsContainer" class="hidden">
+                <div class="bg-white shadow overflow-hidden sm:rounded-lg">
+                    <div class="px-4 py-5 sm:px-6">
+                        <h3 class="text-lg leading-6 font-medium text-gray-900">Search Results</h3>
+                    </div>
+                    <div class="border-t border-gray-200">
+                        <div class="overflow-x-auto">
+                            <table class="min-w-full divide-y divide-gray-200">
+                                <thead class="bg-gray-50">
+                                    <tr>
+                                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Business</th>
+                                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Contact</th>
+                                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Actions</th>
+                                    </tr>
+                                </thead>
+                                <tbody id="resultsBody" class="bg-white divide-y divide-gray-200">
+                                    <!-- Results will be inserted here -->
+                                </tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <script>
+        class SearchProgress {
+            constructor() {
+                this.progressBar = document.getElementById('progressBar');
+                this.progressText = document.getElementById('progressText');
+                this.container = document.getElementById('searchProgress');
+            }
+
+            show() {
+                this.container.classList.remove('hidden');
+                this.setProgress(0, 'Starting search...');
+            }
+
+            hide() {
+                this.container.classList.add('hidden');
+            }
+
+            setProgress(percent, message) {
+                this.progressBar.style.width = `${percent}%`;
+                this.progressText.textContent = message;
+            }
+
+            showError(message) {
+                this.setProgress(100, `Error: ${message}`);
+                this.progressBar.classList.remove('bg-primary');
+                this.progressBar.classList.add('bg-red-500');
+            }
+        }
+
+        async function performSearch() {
+            const query = document.getElementById('searchQuery').value;
+            const location = document.getElementById('searchLocation').value;
+
+            if (!query || !location) {
+                showError('Please enter both search query and location');
+                return;
+            }
+
+            const progress = new SearchProgress();
+            progress.show();
+
+            try {
+                document.getElementById('errorDisplay').classList.add('hidden');
+                document.getElementById('resultsContainer').classList.add('hidden');
+
+                const response = await fetch('/api/search', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ query, location })
+                });
+
+                const data = await response.json();
+
+                if (!data.success) {
+                    throw new Error(data.error || 'Search failed');
+                }
+
+                displayResults(data.results);
+                progress.hide();
+
+            } catch (error) {
+                console.error('Search error:', error);
+                progress.showError(error.message);
+                showError(error.message);
+            }
+        }
+
+        function showError(message) {
+            const errorDisplay = document.getElementById('errorDisplay');
+            const errorMessage = document.getElementById('errorMessage');
+            errorMessage.textContent = message;
+            errorDisplay.classList.remove('hidden');
+        }
+
+        function displayResults(results) {
+            const container = document.getElementById('resultsContainer');
+            const tbody = document.getElementById('resultsBody');
+            
+            tbody.innerHTML = results.map(business => `
+                <tr>
+                    <td class="px-6 py-4">
+                        <div class="text-sm font-medium text-gray-900">${business.name}</div>
+                        <div class="text-sm text-gray-500">${business.description}</div>
+                    </td>
+                    <td class="px-6 py-4">
+                        <div class="text-sm text-gray-900">${business.address}</div>
+                        <div class="text-sm text-gray-500">${business.phone}</div>
+                    </td>
+                    <td class="px-6 py-4">
+                        ${business.website ? 
+                            `<a href="${business.website}" target="_blank" 
+                                class="inline-flex items-center px-3 py-2 border border-transparent text-sm leading-4 font-medium rounded-md text-white bg-primary hover:bg-primary-hover focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-primary">
+                                Visit Website
+                            </a>` : 
+                            '<span class="text-sm text-gray-500">No website available</span>'
+                        }
+                    </td>
+                </tr>
+            `).join('');
+
+            container.classList.remove('hidden');
+        }
+    </script>
+</body>
+</html> 

sample.config.toml

@@ -1,26 +1,14 @@
 [GENERAL]
+PORT = 3001 # Port to run the server on
 SIMILARITY_MEASURE = "cosine" # "cosine" or "dot"
 KEEP_ALIVE = "5m" # How long to keep Ollama models loaded into memory. (Instead of using -1 use "-1m")
 
-[MODELS.OPENAI]
-API_KEY = ""
-
-[MODELS.GROQ]
-API_KEY = ""
-
-[MODELS.ANTHROPIC]
-API_KEY = ""
-
-[MODELS.GEMINI]
-API_KEY = ""
-
-[MODELS.CUSTOM_OPENAI]
-API_KEY = ""
-API_URL = ""
-MODEL_NAME = ""
-
-[MODELS.OLLAMA]
-API_URL = "" # Ollama API URL - http://host.docker.internal:11434
+[API_KEYS]
+OPENAI = "" # OpenAI API key - sk-1234567890abcdef1234567890abcdef
+GROQ = "" # Groq API key - gsk_1234567890abcdef1234567890abcdef
+ANTHROPIC = "" # Anthropic API key - sk-ant-1234567890abcdef1234567890abcdef
+GEMINI = "" # Gemini API key - sk-1234567890abcdef1234567890abcdef
 
 [API_ENDPOINTS]
-SEARXNG = "" # SearxNG API URL - http://localhost:32768
+SEARXNG = "http://localhost:32768" # SearxNG API URL
+OLLAMA = "" # Ollama API URL - http://host.docker.internal:11434

searxng/settings.yml

@@ -11,7 +11,49 @@ search:
 
 server:
   secret_key: 'a2fb23f1b02e6ee83875b09826990de0f6bd908b6638e8c10277d415f6ab852b' # Is overwritten by ${SEARXNG_SECRET}
+  port: 8080
+  bind_address: "0.0.0.0"
+  base_url: http://localhost:8080/
 
 engines:
   - name: wolframalpha
     disabled: false
+
+  - name: google
+    engine: google
+    shortcut: g
+    disabled: false
+
+  - name: bing
+    engine: bing
+    shortcut: b
+    disabled: false
+
+  - name: duckduckgo
+    engine: duckduckgo
+    shortcut: d
+    disabled: false
+
+  - name: yelp
+    engine: yelp
+    shortcut: y
+    disabled: false
+
+ui:
+  static_path: ""
+  templates_path: ""
+  default_theme: simple
+  default_locale: en
+  results_on_new_tab: false
+
+outgoing:
+  request_timeout: 6.0
+  max_request_timeout: 10.0
+  pool_connections: 100
+  pool_maxsize: 10
+  enable_http2: true
+
+server:
+  limiter: false
+  image_proxy: false
+  http_protocol_version: "1.0"

src/app.ts

@@ -0,0 +1,16 @@
+import express from 'express';
+import cors from 'cors';
+import searchRoutes from './routes/search';
+import businessRoutes from './routes/business';
+
+const app = express();
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Routes
+app.use('/api/search', searchRoutes);
+app.use('/api/business', businessRoutes);
+
+export default app;

src/app/api/chat/route.ts

@@ -1,306 +0,0 @@
-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';
-import { searchHandlers } from '@/lib/search';
-
-export const runtime = 'nodejs';
-export const dynamic = 'force-dynamic';
-
-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;
-  systemInstructions: string;
-};
-
-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,
-      body.systemInstructions,
-    );
-
-    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 occurred while processing chat request:', err);
-    return Response.json(
-      { message: 'An error occurred while processing chat request' },
-      { status: 500 },
-    );
-  }
-};

src/app/api/chats/[id]/route.ts

@@ -1,69 +0,0 @@
-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 },
-    );
-  }
-};

src/app/api/chats/route.ts

@@ -1,15 +0,0 @@
-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 },
-    );
-  }
-};

src/app/api/config/route.ts

@@ -1,109 +0,0 @@
-import {
-  getAnthropicApiKey,
-  getCustomOpenaiApiKey,
-  getCustomOpenaiApiUrl,
-  getCustomOpenaiModelName,
-  getGeminiApiKey,
-  getGroqApiKey,
-  getOllamaApiEndpoint,
-  getOpenaiApiKey,
-  updateConfig,
-} from '@/lib/config';
-import {
-  getAvailableChatModelProviders,
-  getAvailableEmbeddingModelProviders,
-} from '@/lib/providers';
-
-export const GET = async (req: Request) => {
-  try {
-    const config: Record<string, any> = {};
-
-    const [chatModelProviders, embeddingModelProviders] = await Promise.all([
-      getAvailableChatModelProviders(),
-      getAvailableEmbeddingModelProviders(),
-    ]);
-
-    config['chatModelProviders'] = {};
-    config['embeddingModelProviders'] = {};
-
-    for (const provider in chatModelProviders) {
-      config['chatModelProviders'][provider] = Object.keys(
-        chatModelProviders[provider],
-      ).map((model) => {
-        return {
-          name: model,
-          displayName: chatModelProviders[provider][model].displayName,
-        };
-      });
-    }
-
-    for (const provider in embeddingModelProviders) {
-      config['embeddingModelProviders'][provider] = Object.keys(
-        embeddingModelProviders[provider],
-      ).map((model) => {
-        return {
-          name: model,
-          displayName: embeddingModelProviders[provider][model].displayName,
-        };
-      });
-    }
-
-    config['openaiApiKey'] = getOpenaiApiKey();
-    config['ollamaApiUrl'] = getOllamaApiEndpoint();
-    config['anthropicApiKey'] = getAnthropicApiKey();
-    config['groqApiKey'] = getGroqApiKey();
-    config['geminiApiKey'] = getGeminiApiKey();
-    config['customOpenaiApiUrl'] = getCustomOpenaiApiUrl();
-    config['customOpenaiApiKey'] = getCustomOpenaiApiKey();
-    config['customOpenaiModelName'] = getCustomOpenaiModelName();
-
-    return Response.json({ ...config }, { status: 200 });
-  } catch (err) {
-    console.error('An error occurred while getting config:', err);
-    return Response.json(
-      { message: 'An error occurred while getting config' },
-      { status: 500 },
-    );
-  }
-};
-
-export const POST = async (req: Request) => {
-  try {
-    const config = await req.json();
-
-    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,
-        },
-      },
-    };
-
-    updateConfig(updatedConfig);
-
-    return Response.json({ message: 'Config updated' }, { status: 200 });
-  } catch (err) {
-    console.error('An error occurred while updating config:', err);
-    return Response.json(
-      { message: 'An error occurred while updating config' },
-      { status: 500 },
-    );
-  }
-};

src/app/api/discover/route.ts

@@ -1,61 +0,0 @@
-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 occurred in discover route: ${err}`);
-    return Response.json(
-      {
-        message: 'An error has occurred',
-      },
-      {
-        status: 500,
-      },
-    );
-  }
-};

src/app/api/images/route.ts

@@ -1,83 +0,0 @@
-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 occurred while searching images: ${err}`);
-    return Response.json(
-      { message: 'An error occurred while searching images' },
-      { status: 500 },
-    );
-  }
-};

src/app/api/models/route.ts

@@ -1,47 +0,0 @@
-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 occurred while fetching models', err);
-    return Response.json(
-      {
-        message: 'An error has occurred.',
-      },
-      {
-        status: 500,
-      },
-    );
-  }
-};

src/app/api/search/route.ts

@@ -1,269 +0,0 @@
-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 { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { MetaSearchAgentType } from '@/lib/search/metaSearchAgent';
-import {
-  getCustomOpenaiApiKey,
-  getCustomOpenaiApiUrl,
-  getCustomOpenaiModelName,
-} from '@/lib/config';
-import { searchHandlers } from '@/lib/search';
-
-interface chatModel {
-  provider: string;
-  name: string;
-  customOpenAIKey?: string;
-  customOpenAIBaseURL?: string;
-}
-
-interface embeddingModel {
-  provider: string;
-  name: string;
-}
-
-interface ChatRequestBody {
-  optimizationMode: 'speed' | 'balanced';
-  focusMode: string;
-  chatModel?: chatModel;
-  embeddingModel?: embeddingModel;
-  query: string;
-  history: Array<[string, string]>;
-  stream?: boolean;
-}
-
-export const POST = async (req: Request) => {
-  try {
-    const body: ChatRequestBody = await req.json();
-
-    if (!body.focusMode || !body.query) {
-      return Response.json(
-        { message: 'Missing focus mode or query' },
-        { status: 400 },
-      );
-    }
-
-    body.history = body.history || [];
-    body.optimizationMode = body.optimizationMode || 'balanced';
-    body.stream = body.stream || false;
-
-    const history: BaseMessage[] = body.history.map((msg) => {
-      return msg[0] === 'human'
-        ? new HumanMessage({ content: msg[1] })
-        : 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?.name ||
-      Object.keys(chatModelProviders[chatModelProvider])[0];
-
-    const embeddingModelProvider =
-      body.embeddingModel?.provider || Object.keys(embeddingModelProviders)[0];
-    const embeddingModel =
-      body.embeddingModel?.name ||
-      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?.name || 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 Response.json(
-        { message: 'Invalid model selected' },
-        { status: 400 },
-      );
-    }
-
-    const searchHandler: MetaSearchAgentType = searchHandlers[body.focusMode];
-
-    if (!searchHandler) {
-      return Response.json({ message: 'Invalid focus mode' }, { status: 400 });
-    }
-
-    const emitter = await searchHandler.searchAndAnswer(
-      body.query,
-      history,
-      llm,
-      embeddings,
-      body.optimizationMode,
-      [],
-      "",
-    );
-
-    if (!body.stream) {
-      return new Promise(
-        (
-          resolve: (value: Response) => void,
-          reject: (value: Response) => void,
-        ) => {
-          let message = '';
-          let sources: any[] = [];
-
-          emitter.on('data', (data: string) => {
-            try {
-              const parsedData = JSON.parse(data);
-              if (parsedData.type === 'response') {
-                message += parsedData.data;
-              } else if (parsedData.type === 'sources') {
-                sources = parsedData.data;
-              }
-            } catch (error) {
-              reject(
-                Response.json(
-                  { message: 'Error parsing data' },
-                  { status: 500 },
-                ),
-              );
-            }
-          });
-
-          emitter.on('end', () => {
-            resolve(Response.json({ message, sources }, { status: 200 }));
-          });
-
-          emitter.on('error', (error: any) => {
-            reject(
-              Response.json(
-                { message: 'Search error', error },
-                { status: 500 },
-              ),
-            );
-          });
-        },
-      );
-    }
-
-    const encoder = new TextEncoder();
-
-    const abortController = new AbortController();
-    const { signal } = abortController;
-
-    const stream = new ReadableStream({
-      start(controller) {
-        let sources: any[] = [];
-
-        controller.enqueue(
-          encoder.encode(
-            JSON.stringify({
-              type: 'init',
-              data: 'Stream connected',
-            }) + '\n',
-          ),
-        );
-
-        signal.addEventListener('abort', () => {
-          emitter.removeAllListeners();
-
-          try {
-            controller.close();
-          } catch (error) {}
-        });
-
-        emitter.on('data', (data: string) => {
-          if (signal.aborted) return;
-
-          try {
-            const parsedData = JSON.parse(data);
-
-            if (parsedData.type === 'response') {
-              controller.enqueue(
-                encoder.encode(
-                  JSON.stringify({
-                    type: 'response',
-                    data: parsedData.data,
-                  }) + '\n',
-                ),
-              );
-            } else if (parsedData.type === 'sources') {
-              sources = parsedData.data;
-              controller.enqueue(
-                encoder.encode(
-                  JSON.stringify({
-                    type: 'sources',
-                    data: sources,
-                  }) + '\n',
-                ),
-              );
-            }
-          } catch (error) {
-            controller.error(error);
-          }
-        });
-
-        emitter.on('end', () => {
-          if (signal.aborted) return;
-
-          controller.enqueue(
-            encoder.encode(
-              JSON.stringify({
-                type: 'done',
-              }) + '\n',
-            ),
-          );
-          controller.close();
-        });
-
-        emitter.on('error', (error: any) => {
-          if (signal.aborted) return;
-
-          controller.error(error);
-        });
-      },
-      cancel() {
-        abortController.abort();
-      },
-    });
-
-    return new Response(stream, {
-      headers: {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache, no-transform',
-        Connection: 'keep-alive',
-      },
-    });
-  } catch (err: any) {
-    console.error(`Error in getting search results: ${err.message}`);
-    return Response.json(
-      { message: 'An error has occurred.' },
-      { status: 500 },
-    );
-  }
-};

src/app/api/suggestions/route.ts

@@ -1,81 +0,0 @@
-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 occurred while generating suggestions: ${err}`);
-    return Response.json(
-      { message: 'An error occurred while generating suggestions' },
-      { status: 500 },
-    );
-  }
-};

src/app/api/uploads/route.ts

@@ -1,134 +0,0 @@
-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 },
-    );
-  }
-}

src/app/api/videos/route.ts

@@ -1,83 +0,0 @@
-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 occurred while searching videos: ${err}`);
-    return Response.json(
-      { message: 'An error occurred while searching videos' },
-      { status: 500 },
-    );
-  }
-};

src/app/c/[chatId]/page.tsx

@@ -1,9 +0,0 @@
-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;

src/app/settings/page.tsx

@@ -1,850 +0,0 @@
-'use client';
-
-import { Settings as SettingsIcon, ArrowLeft, Loader2 } from 'lucide-react';
-import { useEffect, useState } from 'react';
-import { cn } from '@/lib/utils';
-import { Switch } from '@headlessui/react';
-import ThemeSwitcher from '@/components/theme/Switcher';
-import { ImagesIcon, VideoIcon } from 'lucide-react';
-import Link from 'next/link';
-
-interface SettingsType {
-  chatModelProviders: {
-    [key: string]: [Record<string, any>];
-  };
-  embeddingModelProviders: {
-    [key: string]: [Record<string, any>];
-  };
-  openaiApiKey: string;
-  groqApiKey: string;
-  anthropicApiKey: string;
-  geminiApiKey: string;
-  ollamaApiUrl: string;
-  customOpenaiApiKey: string;
-  customOpenaiApiUrl: string;
-  customOpenaiModelName: string;
-}
-
-interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
-  isSaving?: boolean;
-  onSave?: (value: string) => void;
-}
-
-const Input = ({ className, isSaving, onSave, ...restProps }: InputProps) => {
-  return (
-    <div className="relative">
-      <input
-        {...restProps}
-        className={cn(
-          'bg-light-secondary dark:bg-dark-secondary w-full px-3 py-2 flex items-center overflow-hidden border border-light-200 dark:border-dark-200 dark:text-white rounded-lg text-sm',
-          isSaving && 'pr-10',
-          className,
-        )}
-        onBlur={(e) => onSave?.(e.target.value)}
-      />
-      {isSaving && (
-        <div className="absolute right-3 top-1/2 -translate-y-1/2">
-          <Loader2
-            size={16}
-            className="animate-spin text-black/70 dark:text-white/70"
-          />
-        </div>
-      )}
-    </div>
-  );
-};
-
-interface TextareaProps extends React.InputHTMLAttributes<HTMLTextAreaElement> {
-  isSaving?: boolean;
-  onSave?: (value: string) => void;
-}
-
-const Textarea = ({
-  className,
-  isSaving,
-  onSave,
-  ...restProps
-}: TextareaProps) => {
-  return (
-    <div className="relative">
-      <textarea
-        placeholder="Any special instructions for the LLM"
-        className="placeholder:text-sm text-sm w-full flex items-center justify-between p-3 bg-light-secondary dark:bg-dark-secondary rounded-lg hover:bg-light-200 dark:hover:bg-dark-200 transition-colors"
-        rows={4}
-        onBlur={(e) => onSave?.(e.target.value)}
-        {...restProps}
-      />
-      {isSaving && (
-        <div className="absolute right-3 top-3">
-          <Loader2
-            size={16}
-            className="animate-spin text-black/70 dark:text-white/70"
-          />
-        </div>
-      )}
-    </div>
-  );
-};
-
-const Select = ({
-  className,
-  options,
-  ...restProps
-}: React.SelectHTMLAttributes<HTMLSelectElement> & {
-  options: { value: string; label: string; disabled?: boolean }[];
-}) => {
-  return (
-    <select
-      {...restProps}
-      className={cn(
-        'bg-light-secondary dark:bg-dark-secondary px-3 py-2 flex items-center overflow-hidden border border-light-200 dark:border-dark-200 dark:text-white rounded-lg text-sm',
-        className,
-      )}
-    >
-      {options.map(({ label, value, disabled }) => (
-        <option key={value} value={value} disabled={disabled}>
-          {label}
-        </option>
-      ))}
-    </select>
-  );
-};
-
-const SettingsSection = ({
-  title,
-  children,
-}: {
-  title: string;
-  children: React.ReactNode;
-}) => (
-  <div className="flex flex-col space-y-4 p-4 bg-light-secondary/50 dark:bg-dark-secondary/50 rounded-xl border border-light-200 dark:border-dark-200">
-    <h2 className="text-black/90 dark:text-white/90 font-medium">{title}</h2>
-    {children}
-  </div>
-);
-
-const Page = () => {
-  const [config, setConfig] = useState<SettingsType | null>(null);
-  const [chatModels, setChatModels] = useState<Record<string, any>>({});
-  const [embeddingModels, setEmbeddingModels] = useState<Record<string, any>>(
-    {},
-  );
-  const [selectedChatModelProvider, setSelectedChatModelProvider] = useState<
-    string | null
-  >(null);
-  const [selectedChatModel, setSelectedChatModel] = useState<string | null>(
-    null,
-  );
-  const [selectedEmbeddingModelProvider, setSelectedEmbeddingModelProvider] =
-    useState<string | null>(null);
-  const [selectedEmbeddingModel, setSelectedEmbeddingModel] = useState<
-    string | null
-  >(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [automaticImageSearch, setAutomaticImageSearch] = useState(false);
-  const [automaticVideoSearch, setAutomaticVideoSearch] = useState(false);
-  const [systemInstructions, setSystemInstructions] = useState<string>('');
-  const [savingStates, setSavingStates] = useState<Record<string, boolean>>({});
-
-  useEffect(() => {
-    const fetchConfig = async () => {
-      setIsLoading(true);
-      const res = await fetch(`/api/config`, {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
-
-      const data = (await res.json()) as SettingsType;
-      setConfig(data);
-
-      const chatModelProvidersKeys = Object.keys(data.chatModelProviders || {});
-      const embeddingModelProvidersKeys = Object.keys(
-        data.embeddingModelProviders || {},
-      );
-
-      const defaultChatModelProvider =
-        chatModelProvidersKeys.length > 0 ? chatModelProvidersKeys[0] : '';
-      const defaultEmbeddingModelProvider =
-        embeddingModelProvidersKeys.length > 0
-          ? embeddingModelProvidersKeys[0]
-          : '';
-
-      const chatModelProvider =
-        localStorage.getItem('chatModelProvider') ||
-        defaultChatModelProvider ||
-        '';
-      const chatModel =
-        localStorage.getItem('chatModel') ||
-        (data.chatModelProviders &&
-        data.chatModelProviders[chatModelProvider]?.length > 0
-          ? data.chatModelProviders[chatModelProvider][0].name
-          : undefined) ||
-        '';
-      const embeddingModelProvider =
-        localStorage.getItem('embeddingModelProvider') ||
-        defaultEmbeddingModelProvider ||
-        '';
-      const embeddingModel =
-        localStorage.getItem('embeddingModel') ||
-        (data.embeddingModelProviders &&
-          data.embeddingModelProviders[embeddingModelProvider]?.[0].name) ||
-        '';
-
-      setSelectedChatModelProvider(chatModelProvider);
-      setSelectedChatModel(chatModel);
-      setSelectedEmbeddingModelProvider(embeddingModelProvider);
-      setSelectedEmbeddingModel(embeddingModel);
-      setChatModels(data.chatModelProviders || {});
-      setEmbeddingModels(data.embeddingModelProviders || {});
-
-      setAutomaticImageSearch(
-        localStorage.getItem('autoImageSearch') === 'true',
-      );
-      setAutomaticVideoSearch(
-        localStorage.getItem('autoVideoSearch') === 'true',
-      );
-
-      setSystemInstructions(localStorage.getItem('systemInstructions')!);
-
-      setIsLoading(false);
-    };
-
-    fetchConfig();
-  }, []);
-
-  const saveConfig = async (key: string, value: any) => {
-    setSavingStates((prev) => ({ ...prev, [key]: true }));
-
-    try {
-      const updatedConfig = {
-        ...config,
-        [key]: value,
-      } as SettingsType;
-
-      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');
-      }
-
-      setConfig(updatedConfig);
-
-      if (
-        key.toLowerCase().includes('api') ||
-        key.toLowerCase().includes('url')
-      ) {
-        const res = await fetch(`/api/config`, {
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        });
-
-        if (!res.ok) {
-          throw new Error('Failed to fetch updated config');
-        }
-
-        const data = await res.json();
-
-        setChatModels(data.chatModelProviders || {});
-        setEmbeddingModels(data.embeddingModelProviders || {});
-
-        const currentChatProvider = selectedChatModelProvider;
-        const newChatProviders = Object.keys(data.chatModelProviders || {});
-
-        if (!currentChatProvider && newChatProviders.length > 0) {
-          const firstProvider = newChatProviders[0];
-          const firstModel = data.chatModelProviders[firstProvider]?.[0]?.name;
-
-          if (firstModel) {
-            setSelectedChatModelProvider(firstProvider);
-            setSelectedChatModel(firstModel);
-            localStorage.setItem('chatModelProvider', firstProvider);
-            localStorage.setItem('chatModel', firstModel);
-          }
-        } else if (
-          currentChatProvider &&
-          (!data.chatModelProviders ||
-            !data.chatModelProviders[currentChatProvider] ||
-            !Array.isArray(data.chatModelProviders[currentChatProvider]) ||
-            data.chatModelProviders[currentChatProvider].length === 0)
-        ) {
-          const firstValidProvider = Object.entries(
-            data.chatModelProviders || {},
-          ).find(
-            ([_, models]) => Array.isArray(models) && models.length > 0,
-          )?.[0];
-
-          if (firstValidProvider) {
-            setSelectedChatModelProvider(firstValidProvider);
-            setSelectedChatModel(
-              data.chatModelProviders[firstValidProvider][0].name,
-            );
-            localStorage.setItem('chatModelProvider', firstValidProvider);
-            localStorage.setItem(
-              'chatModel',
-              data.chatModelProviders[firstValidProvider][0].name,
-            );
-          } else {
-            setSelectedChatModelProvider(null);
-            setSelectedChatModel(null);
-            localStorage.removeItem('chatModelProvider');
-            localStorage.removeItem('chatModel');
-          }
-        }
-
-        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);
-      }
-
-      if (key === 'automaticImageSearch') {
-        localStorage.setItem('autoImageSearch', value.toString());
-      } else if (key === 'automaticVideoSearch') {
-        localStorage.setItem('autoVideoSearch', value.toString());
-      } else if (key === 'chatModelProvider') {
-        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);
-      } else if (key === 'systemInstructions') {
-        localStorage.setItem('systemInstructions', value);
-      }
-    } catch (err) {
-      console.error('Failed to save:', err);
-      setConfig((prev) => ({ ...prev! }));
-    } finally {
-      setTimeout(() => {
-        setSavingStates((prev) => ({ ...prev, [key]: false }));
-      }, 500);
-    }
-  };
-
-  return (
-    <div className="max-w-3xl mx-auto">
-      <div className="flex flex-col pt-4">
-        <div className="flex items-center space-x-2">
-          <Link href="/" className="lg:hidden">
-            <ArrowLeft className="text-black/70 dark:text-white/70" />
-          </Link>
-          <div className="flex flex-row space-x-0.5 items-center">
-            <SettingsIcon size={23} />
-            <h1 className="text-3xl font-medium p-2">Settings</h1>
-          </div>
-        </div>
-        <hr className="border-t border-[#2B2C2C] my-4 w-full" />
-      </div>
-
-      {isLoading ? (
-        <div className="flex flex-row items-center justify-center min-h-[50vh]">
-          <svg
-            aria-hidden="true"
-            className="w-8 h-8 text-light-200 fill-light-secondary dark:text-[#202020] animate-spin dark:fill-[#ffffff3b]"
-            viewBox="0 0 100 101"
-            fill="none"
-            xmlns="http://www.w3.org/2000/svg"
-          >
-            <path
-              d="M100 50.5908C100.003 78.2051 78.1951 100.003 50.5908 100C22.9765 99.9972 0.997224 78.018 1 50.4037C1.00281 22.7993 22.8108 0.997224 50.4251 1C78.0395 1.00281 100.018 22.8108 100 50.4251ZM9.08164 50.594C9.06312 73.3997 27.7909 92.1272 50.5966 92.1457C73.4023 92.1642 92.1298 73.4365 92.1483 50.6308C92.1669 27.8251 73.4392 9.0973 50.6335 9.07878C27.8278 9.06026 9.10003 27.787 9.08164 50.594Z"
-              fill="currentColor"
-            />
-            <path
-              d="M93.9676 39.0409C96.393 38.4037 97.8624 35.9116 96.9801 33.5533C95.1945 28.8227 92.871 24.3692 90.0681 20.348C85.6237 14.1775 79.4473 9.36872 72.0454 6.45794C64.6435 3.54717 56.3134 2.65431 48.3133 3.89319C45.869 4.27179 44.3768 6.77534 45.014 9.20079C45.6512 11.6262 48.1343 13.0956 50.5786 12.717C56.5073 11.8281 62.5542 12.5399 68.0406 14.7911C73.527 17.0422 78.2187 20.7487 81.5841 25.4923C83.7976 28.5886 85.4467 32.059 86.4416 35.7474C87.1273 38.1189 89.5423 39.6781 91.9676 39.0409Z"
-              fill="currentFill"
-            />
-          </svg>
-        </div>
-      ) : (
-        config && (
-          <div className="flex flex-col space-y-6 pb-28 lg:pb-8">
-            <SettingsSection title="Appearance">
-              <div className="flex flex-col space-y-1">
-                <p className="text-black/70 dark:text-white/70 text-sm">
-                  Theme
-                </p>
-                <ThemeSwitcher />
-              </div>
-            </SettingsSection>
-
-            <SettingsSection title="Automatic Search">
-              <div className="flex flex-col space-y-4">
-                <div className="flex items-center justify-between p-3 bg-light-secondary dark:bg-dark-secondary rounded-lg hover:bg-light-200 dark:hover:bg-dark-200 transition-colors">
-                  <div className="flex items-center space-x-3">
-                    <div className="p-2 bg-light-200 dark:bg-dark-200 rounded-lg">
-                      <ImagesIcon
-                        size={18}
-                        className="text-black/70 dark:text-white/70"
-                      />
-                    </div>
-                    <div>
-                      <p className="text-sm text-black/90 dark:text-white/90 font-medium">
-                        Automatic Image Search
-                      </p>
-                      <p className="text-xs text-black/60 dark:text-white/60 mt-0.5">
-                        Automatically search for relevant images in chat
-                        responses
-                      </p>
-                    </div>
-                  </div>
-                  <Switch
-                    checked={automaticImageSearch}
-                    onChange={(checked) => {
-                      setAutomaticImageSearch(checked);
-                      saveConfig('automaticImageSearch', checked);
-                    }}
-                    className={cn(
-                      automaticImageSearch
-                        ? 'bg-[#24A0ED]'
-                        : 'bg-light-200 dark:bg-dark-200',
-                      'relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none',
-                    )}
-                  >
-                    <span
-                      className={cn(
-                        automaticImageSearch
-                          ? 'translate-x-6'
-                          : 'translate-x-1',
-                        'inline-block h-4 w-4 transform rounded-full bg-white transition-transform',
-                      )}
-                    />
-                  </Switch>
-                </div>
-
-                <div className="flex items-center justify-between p-3 bg-light-secondary dark:bg-dark-secondary rounded-lg hover:bg-light-200 dark:hover:bg-dark-200 transition-colors">
-                  <div className="flex items-center space-x-3">
-                    <div className="p-2 bg-light-200 dark:bg-dark-200 rounded-lg">
-                      <VideoIcon
-                        size={18}
-                        className="text-black/70 dark:text-white/70"
-                      />
-                    </div>
-                    <div>
-                      <p className="text-sm text-black/90 dark:text-white/90 font-medium">
-                        Automatic Video Search
-                      </p>
-                      <p className="text-xs text-black/60 dark:text-white/60 mt-0.5">
-                        Automatically search for relevant videos in chat
-                        responses
-                      </p>
-                    </div>
-                  </div>
-                  <Switch
-                    checked={automaticVideoSearch}
-                    onChange={(checked) => {
-                      setAutomaticVideoSearch(checked);
-                      saveConfig('automaticVideoSearch', checked);
-                    }}
-                    className={cn(
-                      automaticVideoSearch
-                        ? 'bg-[#24A0ED]'
-                        : 'bg-light-200 dark:bg-dark-200',
-                      'relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none',
-                    )}
-                  >
-                    <span
-                      className={cn(
-                        automaticVideoSearch
-                          ? 'translate-x-6'
-                          : 'translate-x-1',
-                        'inline-block h-4 w-4 transform rounded-full bg-white transition-transform',
-                      )}
-                    />
-                  </Switch>
-                </div>
-              </div>
-            </SettingsSection>
-
-            <SettingsSection title="System Instructions">
-              <div className="flex flex-col space-y-4">
-                <Textarea
-                  value={systemInstructions}
-                  isSaving={savingStates['systemInstructions']}
-                  onChange={(e) => {
-                    setSystemInstructions(e.target.value);
-                  }}
-                  onSave={(value) => saveConfig('systemInstructions', value)}
-                />
-              </div>
-            </SettingsSection>
-
-            <SettingsSection title="Model Settings">
-              {config.chatModelProviders && (
-                <div className="flex flex-col space-y-4">
-                  <div className="flex flex-col space-y-1">
-                    <p className="text-black/70 dark:text-white/70 text-sm">
-                      Chat Model Provider
-                    </p>
-                    <Select
-                      value={selectedChatModelProvider ?? undefined}
-                      onChange={(e) => {
-                        const value = e.target.value;
-                        setSelectedChatModelProvider(value);
-                        saveConfig('chatModelProvider', value);
-                        const firstModel =
-                          config.chatModelProviders[value]?.[0]?.name;
-                        if (firstModel) {
-                          setSelectedChatModel(firstModel);
-                          saveConfig('chatModel', firstModel);
-                        }
-                      }}
-                      options={Object.keys(config.chatModelProviders).map(
-                        (provider) => ({
-                          value: provider,
-                          label:
-                            provider.charAt(0).toUpperCase() +
-                            provider.slice(1),
-                        }),
-                      )}
-                    />
-                  </div>
-
-                  {selectedChatModelProvider &&
-                    selectedChatModelProvider != 'custom_openai' && (
-                      <div className="flex flex-col space-y-1">
-                        <p className="text-black/70 dark:text-white/70 text-sm">
-                          Chat Model
-                        </p>
-                        <Select
-                          value={selectedChatModel ?? undefined}
-                          onChange={(e) => {
-                            const value = e.target.value;
-                            setSelectedChatModel(value);
-                            saveConfig('chatModel', value);
-                          }}
-                          options={(() => {
-                            const chatModelProvider =
-                              config.chatModelProviders[
-                                selectedChatModelProvider
-                              ];
-                            return chatModelProvider
-                              ? chatModelProvider.length > 0
-                                ? chatModelProvider.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>
-              )}
-
-              {selectedChatModelProvider &&
-                selectedChatModelProvider === 'custom_openai' && (
-                  <div className="flex flex-col space-y-4">
-                    <div className="flex flex-col space-y-1">
-                      <p className="text-black/70 dark:text-white/70 text-sm">
-                        Model Name
-                      </p>
-                      <Input
-                        type="text"
-                        placeholder="Model name"
-                        value={config.customOpenaiModelName}
-                        isSaving={savingStates['customOpenaiModelName']}
-                        onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
-                          setConfig((prev) => ({
-                            ...prev!,
-                            customOpenaiModelName: e.target.value,
-                          }));
-                        }}
-                        onSave={(value) =>
-                          saveConfig('customOpenaiModelName', value)
-                        }
-                      />
-                    </div>
-                    <div className="flex flex-col space-y-1">
-                      <p className="text-black/70 dark:text-white/70 text-sm">
-                        Custom OpenAI API Key
-                      </p>
-                      <Input
-                        type="text"
-                        placeholder="Custom OpenAI API Key"
-                        value={config.customOpenaiApiKey}
-                        isSaving={savingStates['customOpenaiApiKey']}
-                        onChange={(e: React.ChangeEvent<HTMLInputElement>) => {
-                          setConfig((prev) => ({
-                            ...prev!,
-                            customOpenaiApiKey: e.target.value,
-                          }));
-                        }}
-                        onSave={(value) =>
-                          saveConfig('customOpenaiApiKey', value)
-                        }
-                      />
-                    </div>
-                    <div className="flex flex-col space-y-1">
-                      <p className="text-black/70 dark:text-white/70 text-sm">
-                        Custom OpenAI Base URL
-                      </p>
-                      <Input
-                        type="text"
-                        placeholder="Custom OpenAI Base URL"
-                        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">
-              <div className="flex flex-col space-y-4">
-                <div className="flex flex-col space-y-1">
-                  <p className="text-black/70 dark:text-white/70 text-sm">
-                    OpenAI API Key
-                  </p>
-                  <Input
-                    type="text"
-                    placeholder="OpenAI API Key"
-                    value={config.openaiApiKey}
-                    isSaving={savingStates['openaiApiKey']}
-                    onChange={(e) => {
-                      setConfig((prev) => ({
-                        ...prev!,
-                        openaiApiKey: e.target.value,
-                      }));
-                    }}
-                    onSave={(value) => saveConfig('openaiApiKey', value)}
-                  />
-                </div>
-
-                <div className="flex flex-col space-y-1">
-                  <p className="text-black/70 dark:text-white/70 text-sm">
-                    Ollama API URL
-                  </p>
-                  <Input
-                    type="text"
-                    placeholder="Ollama API URL"
-                    value={config.ollamaApiUrl}
-                    isSaving={savingStates['ollamaApiUrl']}
-                    onChange={(e) => {
-                      setConfig((prev) => ({
-                        ...prev!,
-                        ollamaApiUrl: e.target.value,
-                      }));
-                    }}
-                    onSave={(value) => saveConfig('ollamaApiUrl', value)}
-                  />
-                </div>
-
-                <div className="flex flex-col space-y-1">
-                  <p className="text-black/70 dark:text-white/70 text-sm">
-                    GROQ API Key
-                  </p>
-                  <Input
-                    type="text"
-                    placeholder="GROQ API Key"
-                    value={config.groqApiKey}
-                    isSaving={savingStates['groqApiKey']}
-                    onChange={(e) => {
-                      setConfig((prev) => ({
-                        ...prev!,
-                        groqApiKey: e.target.value,
-                      }));
-                    }}
-                    onSave={(value) => saveConfig('groqApiKey', value)}
-                  />
-                </div>
-
-                <div className="flex flex-col space-y-1">
-                  <p className="text-black/70 dark:text-white/70 text-sm">
-                    Anthropic API Key
-                  </p>
-                  <Input
-                    type="text"
-                    placeholder="Anthropic API key"
-                    value={config.anthropicApiKey}
-                    isSaving={savingStates['anthropicApiKey']}
-                    onChange={(e) => {
-                      setConfig((prev) => ({
-                        ...prev!,
-                        anthropicApiKey: e.target.value,
-                      }));
-                    }}
-                    onSave={(value) => saveConfig('anthropicApiKey', value)}
-                  />
-                </div>
-
-                <div className="flex flex-col space-y-1">
-                  <p className="text-black/70 dark:text-white/70 text-sm">
-                    Gemini API Key
-                  </p>
-                  <Input
-                    type="text"
-                    placeholder="Gemini API key"
-                    value={config.geminiApiKey}
-                    isSaving={savingStates['geminiApiKey']}
-                    onChange={(e) => {
-                      setConfig((prev) => ({
-                        ...prev!,
-                        geminiApiKey: e.target.value,
-                      }));
-                    }}
-                    onSave={(value) => saveConfig('geminiApiKey', value)}
-                  />
-                </div>
-              </div>
-            </SettingsSection>
-          </div>
-        )
-      )}
-    </div>
-  );
-};
-
-export default Page;

src/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 '../searxng';
+import { searchSearxng } from '../lib/searxng';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 
 const imageSearchChainPrompt = `
@@ -36,12 +36,6 @@ type ImageSearchChainInput = {
   query: string;
 };
 
-interface ImageSearchResult {
-  img_src: string;
-  url: string;
-  title: string;
-}
-
 const strParser = new StringOutputParser();
 
 const createImageSearchChain = (llm: BaseChatModel) => {
@@ -58,13 +52,11 @@ const createImageSearchChain = (llm: BaseChatModel) => {
     llm,
     strParser,
     RunnableLambda.from(async (input: string) => {
-      input = input.replace(/<think>.*?<\/think>/g, '');
-
       const res = await searchSearxng(input, {
         engines: ['bing images', 'google images'],
       });
 
-      const images: ImageSearchResult[] = [];
+      const images = [];
 
       res.results.forEach((result) => {
         if (result.img_src && result.url && result.title) {

src/chains/suggestionGeneratorAgent.ts

@@ -1,5 +1,5 @@
 import { RunnableSequence, RunnableMap } from '@langchain/core/runnables';
-import ListLineOutputParser from '../outputParsers/listLineOutputParser';
+import ListLineOutputParser from '../lib/outputParsers/listLineOutputParser';
 import { PromptTemplate } from '@langchain/core/prompts';
 import formatChatHistoryAsString from '../utils/formatHistory';
 import { BaseMessage } from '@langchain/core/messages';

src/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 '../searxng';
+import { searchSearxng } from '../lib/searxng';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 
 const VideoSearchChainPrompt = `
@@ -36,13 +36,6 @@ type VideoSearchChainInput = {
   query: string;
 };
 
-interface VideoSearchResult {
-  img_src: string;
-  url: string;
-  title: string;
-  iframe_src: string;
-}
-
 const strParser = new StringOutputParser();
 
 const createVideoSearchChain = (llm: BaseChatModel) => {
@@ -59,13 +52,11 @@ const createVideoSearchChain = (llm: BaseChatModel) => {
     llm,
     strParser,
     RunnableLambda.from(async (input: string) => {
-      input = input.replace(/<think>.*?<\/think>/g, '');
-
       const res = await searchSearxng(input, {
         engines: ['youtube'],
       });
 
-      const videos: VideoSearchResult[] = [];
+      const videos = [];
 
       res.results.forEach((result) => {
         if (

src/components/ChatWindow.tsx

@@ -1,612 +0,0 @@
-'use client';
-
-import { useEffect, useRef, useState } from 'react';
-import { Document } from '@langchain/core/documents';
-import Navbar from './Navbar';
-import Chat from './Chat';
-import EmptyChat from './EmptyChat';
-import crypto from 'crypto';
-import { toast } from 'sonner';
-import { useSearchParams } from 'next/navigation';
-import { getSuggestions } from '@/lib/actions';
-import { Settings } from 'lucide-react';
-import Link from 'next/link';
-import NextError from 'next/error';
-
-export type Message = {
-  messageId: string;
-  chatId: string;
-  createdAt: Date;
-  content: string;
-  role: 'user' | 'assistant';
-  suggestions?: string[];
-  sources?: Document[];
-};
-
-export interface File {
-  fileName: string;
-  fileExtension: string;
-  fileId: string;
-}
-
-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,
-) => {
-  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(`/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');
-      }
-
-      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);
-      }
-    }
-
-    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 (
-  chatId: string,
-  setMessages: (messages: Message[]) => void,
-  setIsMessagesLoaded: (loaded: boolean) => void,
-  setChatHistory: (history: [string, string][]) => void,
-  setFocusMode: (mode: string) => void,
-  setNotFound: (notFound: boolean) => void,
-  setFiles: (files: File[]) => void,
-  setFileIds: (fileIds: string[]) => void,
-) => {
-  const res = await fetch(`/api/chats/${chatId}`, {
-    method: 'GET',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  });
-
-  if (res.status === 404) {
-    setNotFound(true);
-    setIsMessagesLoaded(true);
-    return;
-  }
-
-  const data = await res.json();
-
-  const messages = data.messages.map((msg: any) => {
-    return {
-      ...msg,
-      ...JSON.parse(msg.metadata),
-    };
-  }) as Message[];
-
-  setMessages(messages);
-
-  const history = messages.map((msg) => {
-    return [msg.role, msg.content];
-  }) as [string, string][];
-
-  console.debug(new Date(), 'app:messages_loaded');
-
-  document.title = messages[0].content;
-
-  const files = data.chat.files.map((file: any) => {
-    return {
-      fileName: file.name,
-      fileExtension: file.name.split('.').pop(),
-      fileId: file.fileId,
-    };
-  });
-
-  setFiles(files);
-  setFileIds(files.map((file: File) => file.fileId));
-
-  setChatHistory(history);
-  setFocusMode(data.chat.focusMode);
-  setIsMessagesLoaded(true);
-};
-
-const ChatWindow = ({ id }: { id?: string }) => {
-  const searchParams = useSearchParams();
-  const initialMessage = searchParams.get('q');
-
-  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);
-
-  useEffect(() => {
-    checkConfig(
-      setChatModelProvider,
-      setEmbeddingModelProvider,
-      setIsConfigReady,
-      setHasError,
-    );
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  const [loading, setLoading] = useState(false);
-  const [messageAppeared, setMessageAppeared] = useState(false);
-
-  const [chatHistory, setChatHistory] = useState<[string, string][]>([]);
-  const [messages, setMessages] = useState<Message[]>([]);
-
-  const [files, setFiles] = useState<File[]>([]);
-  const [fileIds, setFileIds] = useState<string[]>([]);
-
-  const [focusMode, setFocusMode] = useState('webSearch');
-  const [optimizationMode, setOptimizationMode] = useState('speed');
-
-  const [isMessagesLoaded, setIsMessagesLoaded] = useState(false);
-
-  const [notFound, setNotFound] = useState(false);
-
-  useEffect(() => {
-    if (
-      chatId &&
-      !newChatCreated &&
-      !isMessagesLoaded &&
-      messages.length === 0
-    ) {
-      loadMessages(
-        chatId,
-        setMessages,
-        setIsMessagesLoaded,
-        setChatHistory,
-        setFocusMode,
-        setNotFound,
-        setFiles,
-        setFileIds,
-      );
-    } else if (!chatId) {
-      setNewChatCreated(true);
-      setIsMessagesLoaded(true);
-      setChatId(crypto.randomBytes(20).toString('hex'));
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  const messagesRef = useRef<Message[]>([]);
-
-  useEffect(() => {
-    messagesRef.current = messages;
-  }, [messages]);
-
-  useEffect(() => {
-    if (isMessagesLoaded && isConfigReady) {
-      setIsReady(true);
-      console.debug(new Date(), 'app:ready');
-    } else {
-      setIsReady(false);
-    }
-  }, [isMessagesLoaded, isConfigReady]);
-
-  const sendMessage = async (message: string, messageId?: string) => {
-    if (loading) return;
-    if (!isConfigReady) {
-      toast.error('Cannot send message before the configuration is ready');
-      return;
-    }
-
-    setLoading(true);
-    setMessageAppeared(false);
-
-    let sources: Document[] | undefined = undefined;
-    let recievedMessage = '';
-    let added = false;
-
-    messageId = messageId ?? crypto.randomBytes(7).toString('hex');
-
-    setMessages((prevMessages) => [
-      ...prevMessages,
-      {
-        content: message,
-        messageId: messageId,
-        chatId: chatId!,
-        role: 'user',
-        createdAt: new Date(),
-      },
-    ]);
-
-    const messageHandler = async (data: any) => {
-      if (data.type === 'error') {
-        toast.error(data.data);
-        setLoading(false);
-        return;
-      }
-
-      if (data.type === 'sources') {
-        sources = data.data;
-        if (!added) {
-          setMessages((prevMessages) => [
-            ...prevMessages,
-            {
-              content: '',
-              messageId: data.messageId,
-              chatId: chatId!,
-              role: 'assistant',
-              sources: sources,
-              createdAt: new Date(),
-            },
-          ]);
-          added = true;
-        }
-        setMessageAppeared(true);
-      }
-
-      if (data.type === 'message') {
-        if (!added) {
-          setMessages((prevMessages) => [
-            ...prevMessages,
-            {
-              content: data.data,
-              messageId: data.messageId,
-              chatId: chatId!,
-              role: 'assistant',
-              sources: sources,
-              createdAt: new Date(),
-            },
-          ]);
-          added = true;
-        }
-
-        setMessages((prev) =>
-          prev.map((message) => {
-            if (message.messageId === data.messageId) {
-              return { ...message, content: message.content + data.data };
-            }
-
-            return message;
-          }),
-        );
-
-        recievedMessage += data.data;
-        setMessageAppeared(true);
-      }
-
-      if (data.type === 'messageEnd') {
-        setChatHistory((prevHistory) => [
-          ...prevHistory,
-          ['human', message],
-          ['assistant', recievedMessage],
-        ]);
-
-        setLoading(false);
-
-        const lastMsg = messagesRef.current[messagesRef.current.length - 1];
-
-        const autoImageSearch = localStorage.getItem('autoImageSearch');
-        const autoVideoSearch = localStorage.getItem('autoVideoSearch');
-
-        if (autoImageSearch === 'true') {
-          document
-            .getElementById(`search-images-${lastMsg.messageId}`)
-            ?.click();
-        }
-
-        if (autoVideoSearch === 'true') {
-          document
-            .getElementById(`search-videos-${lastMsg.messageId}`)
-            ?.click();
-        }
-
-        if (
-          lastMsg.role === 'assistant' &&
-          lastMsg.sources &&
-          lastMsg.sources.length > 0 &&
-          !lastMsg.suggestions
-        ) {
-          const suggestions = await getSuggestions(messagesRef.current);
-          setMessages((prev) =>
-            prev.map((msg) => {
-              if (msg.messageId === lastMsg.messageId) {
-                return { ...msg, suggestions: suggestions };
-              }
-              return msg;
-            }),
-          );
-        }
-      }
-    };
-
-    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,
-        },
-        systemInstructions: localStorage.getItem('systemInstructions'),
-      }),
-    });
-
-    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) => {
-    const index = messages.findIndex((msg) => msg.messageId === messageId);
-
-    if (index === -1) return;
-
-    const message = messages[index - 1];
-
-    setMessages((prev) => {
-      return [...prev.slice(0, messages.length > 2 ? index - 1 : 0)];
-    });
-    setChatHistory((prev) => {
-      return [...prev.slice(0, messages.length > 2 ? index - 1 : 0)];
-    });
-
-    sendMessage(message.content, message.messageId);
-  };
-
-  useEffect(() => {
-    if (isReady && initialMessage && isConfigReady) {
-      sendMessage(initialMessage);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isConfigReady, isReady, initialMessage]);
-
-  if (hasError) {
-    return (
-      <div className="relative">
-        <div className="absolute w-full flex flex-row items-center justify-end mr-5 mt-5">
-          <Link href="/settings">
-            <Settings className="cursor-pointer lg:hidden" />
-          </Link>
-        </div>
-        <div className="flex flex-col items-center justify-center min-h-screen">
-          <p className="dark:text-white/70 text-black/70 text-sm">
-            Failed to connect to the server. Please try again later.
-          </p>
-        </div>
-      </div>
-    );
-  }
-
-  return isReady ? (
-    notFound ? (
-      <NextError statusCode={404} />
-    ) : (
-      <div>
-        {messages.length > 0 ? (
-          <>
-            <Navbar chatId={chatId!} messages={messages} />
-            <Chat
-              loading={loading}
-              messages={messages}
-              sendMessage={sendMessage}
-              messageAppeared={messageAppeared}
-              rewrite={rewrite}
-              fileIds={fileIds}
-              setFileIds={setFileIds}
-              files={files}
-              setFiles={setFiles}
-            />
-          </>
-        ) : (
-          <EmptyChat
-            sendMessage={sendMessage}
-            focusMode={focusMode}
-            setFocusMode={setFocusMode}
-            optimizationMode={optimizationMode}
-            setOptimizationMode={setOptimizationMode}
-            fileIds={fileIds}
-            setFileIds={setFileIds}
-            files={files}
-            setFiles={setFiles}
-          />
-        )}
-      </div>
-    )
-  ) : (
-    <div className="flex flex-row items-center justify-center min-h-screen">
-      <svg
-        aria-hidden="true"
-        className="w-8 h-8 text-light-200 fill-light-secondary dark:text-[#202020] animate-spin dark:fill-[#ffffff3b]"
-        viewBox="0 0 100 101"
-        fill="none"
-        xmlns="http://www.w3.org/2000/svg"
-      >
-        <path
-          d="M100 50.5908C100.003 78.2051 78.1951 100.003 50.5908 100C22.9765 99.9972 0.997224 78.018 1 50.4037C1.00281 22.7993 22.8108 0.997224 50.4251 1C78.0395 1.00281 100.018 22.8108 100 50.4251ZM9.08164 50.594C9.06312 73.3997 27.7909 92.1272 50.5966 92.1457C73.4023 92.1642 92.1298 73.4365 92.1483 50.6308C92.1669 27.8251 73.4392 9.0973 50.6335 9.07878C27.8278 9.06026 9.10003 27.787 9.08164 50.594Z"
-          fill="currentColor"
-        />
-        <path
-          d="M93.9676 39.0409C96.393 38.4037 97.8624 35.9116 96.9801 33.5533C95.1945 28.8227 92.871 24.3692 90.0681 20.348C85.6237 14.1775 79.4473 9.36872 72.0454 6.45794C64.6435 3.54717 56.3134 2.65431 48.3133 3.89319C45.869 4.27179 44.3768 6.77534 45.014 9.20079C45.6512 11.6262 48.1343 13.0956 50.5786 12.717C56.5073 11.8281 62.5542 12.5399 68.0406 14.7911C73.527 17.0422 78.2187 20.7487 81.5841 25.4923C83.7976 28.5886 85.4467 32.059 86.4416 35.7474C87.1273 38.1189 89.5423 39.6781 91.9676 39.0409Z"
-          fill="currentFill"
-        />
-      </svg>
-    </div>
-  );
-};
-
-export default ChatWindow;

src/components/ThinkBox.tsx

@@ -1,43 +0,0 @@
-'use client';
-
-import { useState } from 'react';
-import { cn } from '@/lib/utils';
-import { ChevronDown, ChevronUp, BrainCircuit } from 'lucide-react';
-
-interface ThinkBoxProps {
-  content: string;
-}
-
-const ThinkBox = ({ content }: ThinkBoxProps) => {
-  const [isExpanded, setIsExpanded] = useState(false);
-
-  return (
-    <div className="my-4 bg-light-secondary/50 dark:bg-dark-secondary/50 rounded-xl border border-light-200 dark:border-dark-200 overflow-hidden">
-      <button
-        onClick={() => setIsExpanded(!isExpanded)}
-        className="w-full flex items-center justify-between px-4 py-1 text-black/90 dark:text-white/90 hover:bg-light-200 dark:hover:bg-dark-200 transition duration-200"
-      >
-        <div className="flex items-center space-x-2">
-          <BrainCircuit
-            size={20}
-            className="text-[#9C27B0] dark:text-[#CE93D8]"
-          />
-          <p className="font-medium text-sm">Thinking Process</p>
-        </div>
-        {isExpanded ? (
-          <ChevronUp size={18} className="text-black/70 dark:text-white/70" />
-        ) : (
-          <ChevronDown size={18} className="text-black/70 dark:text-white/70" />
-        )}
-      </button>
-
-      {isExpanded && (
-        <div className="px-4 py-3 text-black/80 dark:text-white/80 text-sm border-t border-light-200 dark:border-dark-200 bg-light-100/50 dark:bg-dark-100/50 whitespace-pre-wrap">
-          {content}
-        </div>
-      )}
-    </div>
-  );
-};
-
-export default ThinkBox;

src/components/ui/Select.tsx

@@ -1,28 +0,0 @@
-import { cn } from '@/lib/utils';
-import { SelectHTMLAttributes } from 'react';
-
-interface SelectProps extends SelectHTMLAttributes<HTMLSelectElement> {
-  options: { value: string; label: string; disabled?: boolean }[];
-}
-
-export const Select = ({ className, options, ...restProps }: SelectProps) => {
-  return (
-    <select
-      {...restProps}
-      className={cn(
-        'bg-light-secondary dark:bg-dark-secondary px-3 py-2 flex items-center overflow-hidden border border-light-200 dark:border-dark-200 dark:text-white rounded-lg text-sm',
-        className,
-      )}
-    >
-      {options.map(({ label, value, disabled }) => {
-        return (
-          <option key={value} value={value} disabled={disabled}>
-            {label}
-          </option>
-        );
-      })}
-    </select>
-  );
-};
-
-export default Select;

src/config.ts

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import toml from '@iarna/toml';
+
+const configFileName = 'config.toml';
+
+interface Config {
+  GENERAL: {
+    PORT: number;
+    SIMILARITY_MEASURE: string;
+    KEEP_ALIVE: string;
+  };
+  API_KEYS: {
+    OPENAI: string;
+    GROQ: string;
+    ANTHROPIC: string;
+    GEMINI: string;
+  };
+  API_ENDPOINTS: {
+    SEARXNG: string;
+    OLLAMA: string;
+  };
+}
+
+type RecursivePartial<T> = {
+  [P in keyof T]?: RecursivePartial<T[P]>;
+};
+
+const loadConfig = () =>
+  toml.parse(
+    fs.readFileSync(path.join(__dirname, `../${configFileName}`), 'utf-8'),
+  ) as any as Config;
+
+export const getPort = () => loadConfig().GENERAL.PORT;
+
+export const getSimilarityMeasure = () =>
+  loadConfig().GENERAL.SIMILARITY_MEASURE;
+
+export const getKeepAlive = () => loadConfig().GENERAL.KEEP_ALIVE;
+
+export const getOpenaiApiKey = () => loadConfig().API_KEYS.OPENAI;
+
+export const getGroqApiKey = () => loadConfig().API_KEYS.GROQ;
+
+export const getAnthropicApiKey = () => loadConfig().API_KEYS.ANTHROPIC;
+
+export const getGeminiApiKey = () => loadConfig().API_KEYS.GEMINI;
+
+export const getSearxngApiEndpoint = () =>
+  process.env.SEARXNG_API_URL || loadConfig().API_ENDPOINTS.SEARXNG;
+
+export const getOllamaApiEndpoint = () => loadConfig().API_ENDPOINTS.OLLAMA;
+
+export const updateConfig = (config: RecursivePartial<Config>) => {
+  const currentConfig = loadConfig();
+
+  for (const key in currentConfig) {
+    if (!config[key]) config[key] = {};
+
+    if (typeof currentConfig[key] === 'object' && currentConfig[key] !== null) {
+      for (const nestedKey in currentConfig[key]) {
+        if (
+          !config[key][nestedKey] &&
+          currentConfig[key][nestedKey] &&
+          config[key][nestedKey] !== ''
+        ) {
+          config[key][nestedKey] = currentConfig[key][nestedKey];
+        }
+      }
+    } else if (currentConfig[key] && config[key] !== '') {
+      config[key] = currentConfig[key];
+    }
+  }
+
+  fs.writeFileSync(
+    path.join(__dirname, `../${configFileName}`),
+    toml.stringify(config),
+  );
+};
+
+export const config = {
+  ollama: {
+    url: process.env.OLLAMA_URL || 'http://localhost:11434',
+    model: process.env.OLLAMA_MODEL || 'mistral',
+    options: {
+      temperature: 0.1,
+      top_p: 0.9,
+      timeout: 30000 // 30 seconds timeout
+    }
+  },
+  // ... other config
+};

src/config/env.ts

@@ -0,0 +1,40 @@
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+// Environment configuration
+const env = {
+    // Supabase Configuration
+    SUPABASE_URL: process.env.SUPABASE_URL || '',
+    SUPABASE_KEY: process.env.SUPABASE_KEY || '',
+
+    // Server Configuration
+    PORT: parseInt(process.env.PORT || '3001', 10),
+    NODE_ENV: process.env.NODE_ENV || 'development',
+
+    // Search Configuration
+    MAX_RESULTS_PER_QUERY: parseInt(process.env.MAX_RESULTS_PER_QUERY || '50', 10),
+    CACHE_DURATION_HOURS: parseInt(process.env.CACHE_DURATION_HOURS || '24', 10),
+    CACHE_DURATION_DAYS: parseInt(process.env.CACHE_DURATION_DAYS || '7', 10),
+
+    // SearxNG Configuration
+    SEARXNG_URL: process.env.SEARXNG_URL || 'http://localhost:4000',
+
+    // Ollama Configuration
+    OLLAMA_URL: process.env.OLLAMA_URL || 'http://localhost:11434',
+    OLLAMA_MODEL: process.env.OLLAMA_MODEL || 'deepseek-coder:6.7b',
+
+    // Hugging Face Configuration
+    HUGGING_FACE_API_KEY: process.env.HUGGING_FACE_API_KEY || ''
+};
+
+// Validate required environment variables
+const requiredEnvVars = ['SUPABASE_URL', 'SUPABASE_KEY', 'SEARXNG_URL'];
+for (const envVar of requiredEnvVars) {
+    if (!env[envVar as keyof typeof env]) {
+        throw new Error(`Missing required environment variable: ${envVar}`);
+    }
+}
+
+export { env }; 

src/config/index.ts

@@ -0,0 +1,77 @@
+import dotenv from 'dotenv';
+import path from 'path';
+
+// Load .env file
+dotenv.config({ path: path.resolve(__dirname, '../../.env') });
+
+export interface Config {
+  supabase: {
+    url: string;
+    anonKey: string;
+  };
+  server: {
+    port: number;
+    nodeEnv: string;
+  };
+  search: {
+    maxResultsPerQuery: number;
+    cacheDurationHours: number;
+    searxngUrl?: string;
+  };
+  rateLimit: {
+    windowMs: number;
+    maxRequests: number;
+  };
+  security: {
+    corsOrigin: string;
+    jwtSecret: string;
+  };
+  proxy?: {
+    http?: string;
+    https?: string;
+  };
+  logging: {
+    level: string;
+  };
+}
+
+const config: Config = {
+  supabase: {
+    url: process.env.SUPABASE_URL || '',
+    anonKey: process.env.SUPABASE_ANON_KEY || '',
+  },
+  server: {
+    port: parseInt(process.env.PORT || '3000', 10),
+    nodeEnv: process.env.NODE_ENV || 'development',
+  },
+  search: {
+    maxResultsPerQuery: parseInt(process.env.MAX_RESULTS_PER_QUERY || '20', 10),
+    cacheDurationHours: parseInt(process.env.CACHE_DURATION_HOURS || '24', 10),
+    searxngUrl: process.env.SEARXNG_URL
+  },
+  rateLimit: {
+    windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || '900000', 10),
+    maxRequests: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || '100', 10),
+  },
+  security: {
+    corsOrigin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+    jwtSecret: process.env.JWT_SECRET || 'your_jwt_secret_key',
+  },
+  logging: {
+    level: process.env.LOG_LEVEL || 'info',
+  },
+};
+
+// Validate required configuration
+const validateConfig = () => {
+  if (!config.supabase.url) {
+    throw new Error('SUPABASE_URL is required');
+  }
+  if (!config.supabase.anonKey) {
+    throw new Error('SUPABASE_ANON_KEY is required');
+  }
+};
+
+validateConfig();
+
+export { config }; 

src/db/index.ts

@@ -1,9 +1,8 @@
 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(path.join(process.cwd(), 'data/db.sqlite'));
+const sqlite = new Database('data/db.sqlite');
 const db = drizzle(sqlite, {
   schema: schema,
 });

src/index.ts

@@ -0,0 +1,24 @@
+import './config/env'; // Load environment variables first
+import { startServer } from './server';
+import { isPortAvailable } from './utils/portCheck';
+import { testConnection } from './lib/supabase';
+
+const PORT = process.env.PORT || 3001;
+
+const init = async () => {
+  if (!await isPortAvailable(PORT)) {
+    console.error(`Port ${PORT} is in use. Please try a different port or free up the current one.`);
+    process.exit(1);
+  }
+
+  // Test Supabase connection
+  const isConnected = await testConnection();
+  if (!isConnected) {
+    console.error('Failed to connect to Supabase. Please check your configuration.');
+    process.exit(1);
+  }
+
+  startServer();
+};
+
+init().catch(console.error); 

src/lib/categories.ts

@@ -0,0 +1,116 @@
+export interface Category {
+  id: string;
+  name: string;
+  icon: string;
+  subcategories: SubCategory[];
+}
+
+export interface SubCategory {
+  id: string;
+  name: string;
+}
+
+export const categories: Category[] = [
+  {
+    id: 'real-estate-pros',
+    name: 'Real Estate Professionals',
+    icon: '🏢',
+    subcategories: [
+      { id: 'wholesalers', name: 'Real Estate Wholesalers' },
+      { id: 'agents', name: 'Real Estate Agents' },
+      { id: 'attorneys', name: 'Real Estate Attorneys' },
+      { id: 'scouts', name: 'Property Scouts' },
+      { id: 'brokers', name: 'Real Estate Brokers' },
+      { id: 'consultants', name: 'Real Estate Consultants' }
+    ]
+  },
+  {
+    id: 'legal-title',
+    name: 'Legal & Title Services',
+    icon: '⚖️',
+    subcategories: [
+      { id: 'title-companies', name: 'Title Companies' },
+      { id: 'closing-attorneys', name: 'Closing Attorneys' },
+      { id: 'zoning-consultants', name: 'Zoning Consultants' },
+      { id: 'probate-specialists', name: 'Probate Specialists' },
+      { id: 'eviction-specialists', name: 'Eviction Specialists' }
+    ]
+  },
+  {
+    id: 'financial',
+    name: 'Financial Services',
+    icon: '💰',
+    subcategories: [
+      { id: 'hard-money', name: 'Hard Money Lenders' },
+      { id: 'private-equity', name: 'Private Equity Investors' },
+      { id: 'mortgage-brokers', name: 'Mortgage Brokers' },
+      { id: 'tax-advisors', name: 'Tax Advisors' },
+      { id: 'appraisers', name: 'Appraisers' }
+    ]
+  },
+  {
+    id: 'contractors',
+    name: 'Specialist Contractors',
+    icon: '🔨',
+    subcategories: [
+      { id: 'general', name: 'General Contractors' },
+      { id: 'plumbers', name: 'Plumbers' },
+      { id: 'electricians', name: 'Electricians' },
+      { id: 'hvac', name: 'HVAC Technicians' },
+      { id: 'roofers', name: 'Roofers' },
+      { id: 'foundation', name: 'Foundation Specialists' },
+      { id: 'asbestos', name: 'Asbestos Removal' },
+      { id: 'mold', name: 'Mold Remediation' }
+    ]
+  },
+  {
+    id: 'property-services',
+    name: 'Property Services',
+    icon: '🏠',
+    subcategories: [
+      { id: 'surveyors', name: 'Surveyors' },
+      { id: 'inspectors', name: 'Inspectors' },
+      { id: 'property-managers', name: 'Property Managers' },
+      { id: 'environmental', name: 'Environmental Consultants' },
+      { id: 'junk-removal', name: 'Junk Removal Services' },
+      { id: 'cleaning', name: 'Property Cleaning' }
+    ]
+  },
+  {
+    id: 'marketing',
+    name: 'Marketing & Lead Gen',
+    icon: '📢',
+    subcategories: [
+      { id: 'direct-mail', name: 'Direct Mail Services' },
+      { id: 'social-media', name: 'Social Media Marketing' },
+      { id: 'seo', name: 'SEO Specialists' },
+      { id: 'ppc', name: 'PPC Advertising' },
+      { id: 'lead-gen', name: 'Lead Generation' },
+      { id: 'skip-tracing', name: 'Skip Tracing Services' }
+    ]
+  },
+  {
+    id: 'data-tech',
+    name: 'Data & Technology',
+    icon: '💻',
+    subcategories: [
+      { id: 'data-providers', name: 'Property Data Providers' },
+      { id: 'crm', name: 'CRM Systems' },
+      { id: 'valuation', name: 'Valuation Tools' },
+      { id: 'virtual-tours', name: 'Virtual Tour Services' },
+      { id: 'automation', name: 'Automation Tools' }
+    ]
+  },
+  {
+    id: 'specialty',
+    name: 'Specialty Services',
+    icon: '🎯',
+    subcategories: [
+      { id: 'auction', name: 'Auction Companies' },
+      { id: 'relocation', name: 'Relocation Services' },
+      { id: 'staging', name: 'Home Staging' },
+      { id: 'photography', name: 'Real Estate Photography' },
+      { id: 'virtual-assistant', name: 'Virtual Assistants' }
+    ]
+  }
+]; 

src/lib/config.ts

@@ -1,113 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import toml from '@iarna/toml';
-
-const configFileName = 'config.toml';
-
-interface Config {
-  GENERAL: {
-    SIMILARITY_MEASURE: string;
-    KEEP_ALIVE: string;
-  };
-  MODELS: {
-    OPENAI: {
-      API_KEY: string;
-    };
-    GROQ: {
-      API_KEY: string;
-    };
-    ANTHROPIC: {
-      API_KEY: string;
-    };
-    GEMINI: {
-      API_KEY: string;
-    };
-    OLLAMA: {
-      API_URL: string;
-    };
-    CUSTOM_OPENAI: {
-      API_URL: string;
-      API_KEY: string;
-      MODEL_NAME: string;
-    };
-  };
-  API_ENDPOINTS: {
-    SEARXNG: string;
-  };
-}
-
-type RecursivePartial<T> = {
-  [P in keyof T]?: RecursivePartial<T[P]>;
-};
-
-const loadConfig = () =>
-  toml.parse(
-    fs.readFileSync(path.join(process.cwd(), `${configFileName}`), 'utf-8'),
-  ) as any as Config;
-
-export const getSimilarityMeasure = () =>
-  loadConfig().GENERAL.SIMILARITY_MEASURE;
-
-export const getKeepAlive = () => loadConfig().GENERAL.KEEP_ALIVE;
-
-export const getOpenaiApiKey = () => loadConfig().MODELS.OPENAI.API_KEY;
-
-export const getGroqApiKey = () => loadConfig().MODELS.GROQ.API_KEY;
-
-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;
-
-export const getOllamaApiEndpoint = () => loadConfig().MODELS.OLLAMA.API_URL;
-
-export const getCustomOpenaiApiKey = () =>
-  loadConfig().MODELS.CUSTOM_OPENAI.API_KEY;
-
-export const getCustomOpenaiApiUrl = () =>
-  loadConfig().MODELS.CUSTOM_OPENAI.API_URL;
-
-export const getCustomOpenaiModelName = () =>
-  loadConfig().MODELS.CUSTOM_OPENAI.MODEL_NAME;
-
-const mergeConfigs = (current: any, update: any): any => {
-  if (update === null || update === undefined) {
-    return current;
-  }
-
-  if (typeof current !== 'object' || current === null) {
-    return update;
-  }
-
-  const result = { ...current };
-
-  for (const key in update) {
-    if (Object.prototype.hasOwnProperty.call(update, key)) {
-      const updateValue = update[key];
-
-      if (
-        typeof updateValue === 'object' &&
-        updateValue !== null &&
-        typeof result[key] === 'object' &&
-        result[key] !== null
-      ) {
-        result[key] = mergeConfigs(result[key], updateValue);
-      } else if (updateValue !== undefined) {
-        result[key] = updateValue;
-      }
-    }
-  }
-
-  return result;
-};
-
-export const updateConfig = (config: RecursivePartial<Config>) => {
-  const currentConfig = loadConfig();
-  const mergedConfig = mergeConfigs(currentConfig, config);
-  fs.writeFileSync(
-    path.join(path.join(process.cwd(), `${configFileName}`)),
-    toml.stringify(mergedConfig),
-  );
-};

src/lib/db/optOutDb.ts

@@ -0,0 +1,51 @@
+import { Database } from 'better-sqlite3';
+import path from 'path';
+
+interface OptOutEntry {
+  domain: string;
+  email: string;
+  reason?: string;
+  timestamp: Date;
+}
+
+export class OptOutDatabase {
+  private db: Database;
+
+  constructor() {
+    this.db = new Database(path.join(__dirname, '../../../data/optout.db'));
+    this.initializeDatabase();
+  }
+
+  private initializeDatabase() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS opt_outs (
+        domain TEXT PRIMARY KEY,
+        email TEXT NOT NULL,
+        reason TEXT,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX IF NOT EXISTS idx_domain ON opt_outs(domain);
+    `);
+  }
+
+  async addOptOut(entry: OptOutEntry): Promise<void> {
+    const stmt = this.db.prepare(
+      'INSERT OR REPLACE INTO opt_outs (domain, email, reason, timestamp) VALUES (?, ?, ?, ?)'
+    );
+    stmt.run(entry.domain, entry.email, entry.reason, entry.timestamp.toISOString());
+  }
+
+  isOptedOut(domain: string): boolean {
+    const stmt = this.db.prepare('SELECT 1 FROM opt_outs WHERE domain = ?');
+    return stmt.get(domain) !== undefined;
+  }
+
+  removeOptOut(domain: string): void {
+    const stmt = this.db.prepare('DELETE FROM opt_outs WHERE domain = ?');
+    stmt.run(domain);
+  }
+
+  getOptOutList(): OptOutEntry[] {
+    return this.db.prepare('SELECT * FROM opt_outs').all();
+  }
+} 

src/lib/db/supabase.ts

@@ -0,0 +1,74 @@
+import { createClient } from '@supabase/supabase-js';
+import { BusinessData } from '../searxng';
+import { env } from '../../config/env';
+
+// Create the Supabase client with validated environment variables
+export const supabase = createClient(
+  env.supabase.url,
+  env.supabase.anonKey,
+  {
+    auth: {
+      persistSession: false // Since this is a server environment
+    }
+  }
+);
+
+// Define the cache record type
+export interface CacheRecord {
+  id: string;
+  query: string;
+  results: BusinessData[];
+  location: string;
+  category: string;
+  created_at: string;
+  updated_at: string;
+  expires_at: string;
+}
+
+// Export database helper functions
+export async function getCacheEntry(
+  category: string,
+  location: string
+): Promise<CacheRecord | null> {
+  const { data, error } = await supabase
+    .from('search_cache')
+    .select('*')
+    .eq('category', category.toLowerCase())
+    .eq('location', location.toLowerCase())
+    .gt('expires_at', new Date().toISOString())
+    .order('created_at', { ascending: false })
+    .limit(1)
+    .single();
+
+  if (error) {
+    console.error('Cache lookup failed:', error);
+    return null;
+  }
+
+  return data;
+}
+
+export async function saveCacheEntry(
+  category: string,
+  location: string,
+  results: BusinessData[],
+  expiresInDays: number = 7
+): Promise<void> {
+  const expiresAt = new Date();
+  expiresAt.setDate(expiresAt.getDate() + expiresInDays);
+
+  const { error } = await supabase
+    .from('search_cache')
+    .insert({
+      query: `${category} in ${location}`,
+      category: category.toLowerCase(),
+      location: location.toLowerCase(),
+      results,
+      expires_at: expiresAt.toISOString()
+    });
+
+  if (error) {
+    console.error('Failed to save cache entry:', error);
+    throw error;
+  }
+} 

src/lib/emailScraper.ts

@@ -0,0 +1,195 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { Cache } from './utils/cache';
+import { RateLimiter } from './utils/rateLimiter';
+import robotsParser from 'robots-parser';
+
+interface ScrapingResult {
+  emails: string[];
+  phones: string[];
+  addresses: string[];
+  socialLinks: string[];
+  source: string;
+  timestamp: Date;
+  attribution: string;
+}
+
+export class EmailScraper {
+  private cache: Cache<ScrapingResult>;
+  private rateLimiter: RateLimiter;
+  private robotsCache = new Map<string, any>();
+
+  constructor(private options = { 
+    timeout: 5000,
+    cacheTTL: 60,
+    rateLimit: { windowMs: 60000, maxRequests: 10 }, // More conservative rate limiting
+    userAgent: 'BizSearch/1.0 (+https://your-domain.com/about) - Business Directory Service'
+  }) {
+    this.cache = new Cache<ScrapingResult>(options.cacheTTL);
+    this.rateLimiter = new RateLimiter(options.rateLimit.windowMs, options.rateLimit.maxRequests);
+  }
+
+  private async checkRobotsPermission(url: string): Promise<boolean> {
+    try {
+      const { protocol, host } = new URL(url);
+      const robotsUrl = `${protocol}//${host}/robots.txt`;
+      
+      let parser = this.robotsCache.get(host);
+      if (!parser) {
+        const response = await axios.get(robotsUrl);
+        parser = robotsParser(robotsUrl, response.data);
+        this.robotsCache.set(host, parser);
+      }
+
+      return parser.isAllowed(url, this.options.userAgent);
+    } catch (error) {
+      console.warn(`Could not check robots.txt for ${url}:`, error);
+      return true; // Assume allowed if robots.txt is unavailable
+    }
+  }
+
+  async scrapeEmails(url: string): Promise<ScrapingResult> {
+    // Check cache first
+    const cached = this.cache.get(url);
+    if (cached) return cached;
+
+    // Check robots.txt
+    const allowed = await this.checkRobotsPermission(url);
+    if (!allowed) {
+      console.log(`Respecting robots.txt disallow for ${url}`);
+      return {
+        emails: [],
+        phones: [],
+        addresses: [],
+        socialLinks: [],
+        source: url,
+        timestamp: new Date(),
+        attribution: 'Restricted by robots.txt'
+      };
+    }
+
+    // Wait for rate limiting slot
+    await this.rateLimiter.waitForSlot();
+
+    try {
+      const response = await axios.get(url, {
+        timeout: this.options.timeout,
+        headers: {
+          'User-Agent': this.options.userAgent,
+          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        }
+      });
+
+      // Check for noindex meta tag
+      const $ = cheerio.load(response.data);
+      if ($('meta[name="robots"][content*="noindex"]').length > 0) {
+        return {
+          emails: [],
+          phones: [],
+          addresses: [],
+          socialLinks: [],
+          source: url,
+          timestamp: new Date(),
+          attribution: 'Respecting noindex directive'
+        };
+      }
+
+      // Only extract contact information from public contact pages or structured data
+      const isContactPage = /contact|about/i.test(url) || 
+                          $('h1, h2').text().toLowerCase().includes('contact');
+
+      const result = {
+        emails: new Set<string>(),
+        phones: new Set<string>(),
+        addresses: new Set<string>(),
+        socialLinks: new Set<string>(),
+        source: url,
+        timestamp: new Date(),
+        attribution: `Data from public business listing at ${new URL(url).hostname}`
+      };
+
+      // Extract from structured data (Schema.org)
+      $('script[type="application/ld+json"]').each((_, element) => {
+        try {
+          const data = JSON.parse($(element).html() || '{}');
+          if (data['@type'] === 'LocalBusiness' || data['@type'] === 'Organization') {
+            if (data.email) result.emails.add(data.email.toLowerCase());
+            if (data.telephone) result.phones.add(this.formatPhoneNumber(data.telephone));
+            if (data.address) {
+              const fullAddress = this.formatAddress(data.address);
+              if (fullAddress) result.addresses.add(fullAddress);
+            }
+          }
+        } catch (e) {
+          console.error('Error parsing JSON-LD:', e);
+        }
+      });
+
+      // Only scrape additional info if it's a contact page
+      if (isContactPage) {
+        // Extract clearly marked contact information
+        $('[itemprop="email"], .contact-email, .email').each((_, element) => {
+          const email = $(element).text().trim();
+          if (this.isValidEmail(email)) {
+            result.emails.add(email.toLowerCase());
+          }
+        });
+
+        $('[itemprop="telephone"], .phone, .contact-phone').each((_, element) => {
+          const phone = $(element).text().trim();
+          const formatted = this.formatPhoneNumber(phone);
+          if (formatted) result.phones.add(formatted);
+        });
+      }
+
+      const finalResult = {
+        ...result,
+        emails: Array.from(result.emails),
+        phones: Array.from(result.phones),
+        addresses: Array.from(result.addresses),
+        socialLinks: Array.from(result.socialLinks)
+      };
+
+      this.cache.set(url, finalResult);
+      return finalResult;
+
+    } catch (error) {
+      console.error(`Failed to scrape ${url}:`, error);
+      return {
+        emails: [],
+        phones: [],
+        addresses: [],
+        socialLinks: [],
+        source: url,
+        timestamp: new Date(),
+        attribution: 'Error accessing page'
+      };
+    }
+  }
+
+  private isValidEmail(email: string): boolean {
+    return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email);
+  }
+
+  private formatPhoneNumber(phone: string): string {
+    const digits = phone.replace(/\D/g, '');
+    if (digits.length === 10) {
+      return `(${digits.slice(0,3)}) ${digits.slice(3,6)}-${digits.slice(6)}`;
+    }
+    return phone;
+  }
+
+  private formatAddress(address: any): string | null {
+    if (typeof address === 'string') return address;
+    if (typeof address === 'object') {
+      const parts = [
+        address.streetAddress,
+        address.addressLocality,
+        address.addressRegion,
+        address.postalCode
+      ].filter(Boolean);
+      if (parts.length > 0) return parts.join(', ');
+    }
+    return null;
+  }
+} 

src/lib/huggingfaceTransformer.ts

@@ -28,7 +28,7 @@ export class HuggingFaceTransformersEmbeddings
 
   timeout?: number;
 
-  private pipelinePromise: Promise<any> | undefined;
+  private pipelinePromise: Promise<any>;
 
   constructor(fields?: Partial<HuggingFaceTransformersEmbeddingsParams>) {
     super(fields ?? {});

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() {

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() {

src/lib/providers/anthropic.ts

@@ -1,38 +1,6 @@
 import { ChatAnthropic } from '@langchain/anthropic';
-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',
-  },
-];
+import { getAnthropicApiKey } from '../../config';
+import logger from '../../utils/logger';
 
 export const loadAnthropicChatModels = async () => {
   const anthropicApiKey = getAnthropicApiKey();
@@ -40,22 +8,52 @@ export const loadAnthropicChatModels = async () => {
   if (!anthropicApiKey) return {};
 
   try {
-    const chatModels: Record<string, ChatModel> = {};
-
-    anthropicChatModels.forEach((model) => {
-      chatModels[model.key] = {
-        displayName: model.displayName,
+    const chatModels = {
+      'claude-3-5-sonnet-20241022': {
+        displayName: 'Claude 3.5 Sonnet',
         model: new ChatAnthropic({
-          apiKey: anthropicApiKey,
-          modelName: model.key,
           temperature: 0.7,
-        }) as unknown as BaseChatModel,
-      };
-    });
+          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',
+        }),
+      },
+    };
 
     return chatModels;
   } catch (err) {
-    console.error(`Error loading Anthropic models: ${err}`);
+    logger.error(`Error loading Anthropic models: ${err}`);
     return {};
   }
 };

src/lib/providers/business/index.ts

@@ -0,0 +1,19 @@
+import { Business, SearchParams } from '../../../types/business';
+import { WebScraperProvider } from './webScraper';
+
+export class BusinessProvider {
+  private scraper: WebScraperProvider;
+
+  constructor() {
+    this.scraper = new WebScraperProvider();
+  }
+
+  async search(params: SearchParams): Promise<Business[]> {
+    return this.scraper.search(params);
+  }
+
+  async getDetails(businessId: string): Promise<Business | null> {
+    // Implement detailed business lookup using stored data or additional scraping
+    return null;
+  }
+} 

src/lib/providers/business/webScraper.ts

@@ -0,0 +1,111 @@
+import { Business, SearchParams } from '../../../types/business';
+import { searchWeb } from '../search'; // This is Perplexica's existing search function
+import { parseHTML } from '../utils/parser';
+
+export class WebScraperProvider {
+  async search(params: SearchParams): Promise<Business[]> {
+    const searchQueries = this.generateQueries(params);
+    const businesses: Business[] = [];
+
+    for (const query of searchQueries) {
+      // Use Perplexica's existing search functionality
+      const results = await searchWeb(query, {
+        maxResults: 20,
+        type: 'general'  // or 'news' depending on what we want
+      });
+
+      for (const result of results) {
+        try {
+          const html = await fetch(result.url).then(res => res.text());
+          const businessData = await this.extractBusinessData(html, result.url);
+          if (businessData) {
+            businesses.push(businessData);
+          }
+        } catch (error) {
+          console.error(`Failed to extract data from ${result.url}:`, error);
+        }
+      }
+    }
+
+    return this.deduplicateBusinesses(businesses);
+  }
+
+  private generateQueries(params: SearchParams): string[] {
+    const { location, category } = params;
+    return [
+      `${category} in ${location}`,
+      `${category} business ${location}`,
+      `best ${category} near ${location}`,
+      `${category} services ${location} reviews`
+    ];
+  }
+
+  private async extractBusinessData(html: string, sourceUrl: string): Promise<Business | null> {
+    const $ = parseHTML(html);
+    
+    // Different extraction logic based on source
+    if (sourceUrl.includes('yelp.com')) {
+      return this.extractYelpData($);
+    } else if (sourceUrl.includes('yellowpages.com')) {
+      return this.extractYellowPagesData($);
+    }
+    // ... other source-specific extractors
+
+    return null;
+  }
+
+  private extractYelpData($: any): Business | null {
+    try {
+      return {
+        id: crypto.randomUUID(),
+        name: $('.business-name').text().trim(),
+        phone: $('.phone-number').text().trim(),
+        address: $('.address').text().trim(),
+        city: $('.city').text().trim(),
+        state: $('.state').text().trim(),
+        zip: $('.zip').text().trim(),
+        category: $('.category-str-list').text().split(',').map(s => s.trim()),
+        rating: parseFloat($('.rating').text()),
+        reviewCount: parseInt($('.review-count').text()),
+        services: $('.services-list').text().split(',').map(s => s.trim()),
+        hours: this.extractHours($),
+        website: $('.website-link').attr('href'),
+        verified: false,
+        lastUpdated: new Date()
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private deduplicateBusinesses(businesses: Business[]): Business[] {
+    // Group by phone number and address to identify duplicates
+    const uniqueBusinesses = new Map<string, Business>();
+    
+    for (const business of businesses) {
+      const key = `${business.phone}-${business.address}`.toLowerCase();
+      if (!uniqueBusinesses.has(key)) {
+        uniqueBusinesses.set(key, business);
+      } else {
+        // Merge data if we have additional information
+        const existing = uniqueBusinesses.get(key)!;
+        uniqueBusinesses.set(key, this.mergeBusinessData(existing, business));
+      }
+    }
+
+    return Array.from(uniqueBusinesses.values());
+  }
+
+  private mergeBusinessData(existing: Business, newData: Business): Business {
+    return {
+      ...existing,
+      services: [...new Set([...existing.services, ...newData.services])],
+      rating: (existing.rating + newData.rating) / 2,
+      reviewCount: existing.reviewCount + newData.reviewCount,
+      // Keep the most complete data for other fields
+      website: existing.website || newData.website,
+      email: existing.email || newData.email,
+      hours: existing.hours || newData.hours
+    };
+  }
+} 

src/lib/providers/gemini.ts

@@ -2,48 +2,8 @@ import {
   ChatGoogleGenerativeAI,
   GoogleGenerativeAIEmbeddings,
 } from '@langchain/google-genai';
-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.5 Pro Experimental',
-    key: 'gemini-2.5-pro-exp-03-25',
-  },
-  {
-    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 Flash Thinking Experimental',
-    key: 'gemini-2.0-flash-thinking-exp-01-21',
-  },
-  {
-    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',
-  },
-];
+import { getGeminiApiKey } from '../../config';
+import logger from '../../utils/logger';
 
 export const loadGeminiChatModels = async () => {
   const geminiApiKey = getGeminiApiKey();
@@ -51,47 +11,59 @@ export const loadGeminiChatModels = async () => {
   if (!geminiApiKey) return {};
 
   try {
-    const chatModels: Record<string, ChatModel> = {};
-
-    geminiChatModels.forEach((model) => {
-      chatModels[model.key] = {
-        displayName: model.displayName,
+    const chatModels = {
+      'gemini-1.5-flash': {
+        displayName: 'Gemini 1.5 Flash',
         model: new ChatGoogleGenerativeAI({
-          apiKey: geminiApiKey,
-          modelName: model.key,
+          modelName: 'gemini-1.5-flash',
           temperature: 0.7,
-        }) as unknown as BaseChatModel,
-      };
-    });
+          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,
+        }),
+      },
+    };
 
     return chatModels;
   } catch (err) {
-    console.error(`Error loading Gemini models: ${err}`);
+    logger.error(`Error loading Gemini models: ${err}`);
     return {};
   }
 };
 
-export const loadGeminiEmbeddingModels = async () => {
+export const loadGeminiEmbeddingsModels = async () => {
   const geminiApiKey = getGeminiApiKey();
 
   if (!geminiApiKey) return {};
 
   try {
-    const embeddingModels: Record<string, EmbeddingModel> = {};
-
-    geminiEmbeddingModels.forEach((model) => {
-      embeddingModels[model.key] = {
-        displayName: model.displayName,
+    const embeddingModels = {
+      'text-embedding-004': {
+        displayName: 'Text Embedding',
         model: new GoogleGenerativeAIEmbeddings({
           apiKey: geminiApiKey,
-          modelName: model.key,
-        }) as unknown as Embeddings,
-      };
-    });
+          modelName: 'text-embedding-004',
+        }),
+      },
+    };
 
     return embeddingModels;
   } catch (err) {
-    console.error(`Error loading OpenAI embeddings models: ${err}`);
+    logger.error(`Error loading Gemini embeddings model: ${err}`);
     return {};
   }
 };

src/lib/providers/groq.ts

@@ -1,78 +1,6 @@
 import { ChatOpenAI } from '@langchain/openai';
-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 (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',
-  },
-];
+import { getGroqApiKey } from '../../config';
+import logger from '../../utils/logger';
 
 export const loadGroqChatModels = async () => {
   const groqApiKey = getGroqApiKey();
@@ -80,25 +8,129 @@ export const loadGroqChatModels = async () => {
   if (!groqApiKey) return {};
 
   try {
-    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: {
+    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,
+          },
+          {
             baseURL: 'https://api.groq.com/openai/v1',
           },
-        }) as unknown as BaseChatModel,
-      };
-    });
+        ),
+      },
+      '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',
+          },
+        ),
+      },
+    };
 
     return chatModels;
   } catch (err) {
-    console.error(`Error loading Groq models: ${err}`);
+    logger.error(`Error loading Groq models: ${err}`);
     return {};
   }
 };

src/lib/providers/index.ts

@@ -1,51 +1,27 @@
-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';
-import { ChatOpenAI } from '@langchain/openai';
-import { loadOllamaChatModels, loadOllamaEmbeddingModels } from './ollama';
 import { loadGroqChatModels } from './groq';
+import { loadOllamaChatModels, loadOllamaEmbeddingsModels } from './ollama';
+import { loadOpenAIChatModels, loadOpenAIEmbeddingsModels } from './openai';
 import { loadAnthropicChatModels } from './anthropic';
-import { loadGeminiChatModels, loadGeminiEmbeddingModels } from './gemini';
 import { loadTransformersEmbeddingsModels } from './transformers';
+import { loadGeminiChatModels, loadGeminiEmbeddingsModels } from './gemini';
 
-export interface ChatModel {
-  displayName: string;
-  model: BaseChatModel;
-}
-
-export interface EmbeddingModel {
-  displayName: string;
-  model: Embeddings;
-}
-
-export const chatModelProviders: Record<
-  string,
-  () => Promise<Record<string, ChatModel>>
-> = {
+const chatModelProviders = {
   openai: loadOpenAIChatModels,
-  ollama: loadOllamaChatModels,
   groq: loadGroqChatModels,
+  ollama: loadOllamaChatModels,
   anthropic: loadAnthropicChatModels,
   gemini: loadGeminiChatModels,
 };
 
-export const embeddingModelProviders: Record<
-  string,
-  () => Promise<Record<string, EmbeddingModel>>
-> = {
-  openai: loadOpenAIEmbeddingModels,
-  ollama: loadOllamaEmbeddingModels,
-  gemini: loadGeminiEmbeddingModels,
-  transformers: loadTransformersEmbeddingsModels,
+const embeddingModelProviders = {
+  openai: loadOpenAIEmbeddingsModels,
+  local: loadTransformersEmbeddingsModels,
+  ollama: loadOllamaEmbeddingsModels,
+  gemini: loadGeminiEmbeddingsModels,
 };
 
 export const getAvailableChatModelProviders = async () => {
-  const models: Record<string, Record<string, ChatModel>> = {};
+  const models = {};
 
   for (const provider in chatModelProviders) {
     const providerModels = await chatModelProviders[provider]();
@@ -54,33 +30,13 @@ export const getAvailableChatModelProviders = async () => {
     }
   }
 
-  const customOpenAiApiKey = getCustomOpenaiApiKey();
-  const customOpenAiApiUrl = getCustomOpenaiApiUrl();
-  const customOpenAiModelName = getCustomOpenaiModelName();
-
-  models['custom_openai'] = {
-    ...(customOpenAiApiKey && customOpenAiApiUrl && customOpenAiModelName
-      ? {
-          [customOpenAiModelName]: {
-            displayName: customOpenAiModelName,
-            model: new ChatOpenAI({
-              openAIApiKey: customOpenAiApiKey,
-              modelName: customOpenAiModelName,
-              temperature: 0.7,
-              configuration: {
-                baseURL: customOpenAiApiUrl,
-              },
-            }) as unknown as BaseChatModel,
-          },
-        }
-      : {}),
-  };
+  models['custom_openai'] = {};
 
   return models;
 };
 
 export const getAvailableEmbeddingModelProviders = async () => {
-  const models: Record<string, Record<string, EmbeddingModel>> = {};
+  const models = {};
 
   for (const provider in embeddingModelProviders) {
     const providerModels = await embeddingModelProviders[provider]();

src/lib/providers/ollama.ts

@@ -1,73 +1,74 @@
-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';
+import { getKeepAlive, getOllamaApiEndpoint } from '../../config';
+import logger from '../../utils/logger';
+import { ChatOllama } from '@langchain/community/chat_models/ollama';
+import axios from 'axios';
 
 export const loadOllamaChatModels = async () => {
-  const ollamaApiEndpoint = getOllamaApiEndpoint();
+  const ollamaEndpoint = getOllamaApiEndpoint();
+  const keepAlive = getKeepAlive();
 
-  if (!ollamaApiEndpoint) return {};
+  if (!ollamaEndpoint) return {};
 
   try {
-    const res = await axios.get(`${ollamaApiEndpoint}/api/tags`, {
+    const response = await axios.get(`${ollamaEndpoint}/api/tags`, {
       headers: {
         'Content-Type': 'application/json',
       },
     });
 
-    const { models } = res.data;
+    const { models: ollamaModels } = response.data;
 
-    const chatModels: Record<string, ChatModel> = {};
-
-    models.forEach((model: any) => {
-      chatModels[model.model] = {
+    const chatModels = ollamaModels.reduce((acc, model) => {
+      acc[model.model] = {
         displayName: model.name,
         model: new ChatOllama({
-          baseUrl: ollamaApiEndpoint,
+          baseUrl: ollamaEndpoint,
           model: model.model,
           temperature: 0.7,
-          keepAlive: getKeepAlive(),
+          keepAlive: keepAlive,
         }),
       };
-    });
+
+      return acc;
+    }, {});
 
     return chatModels;
   } catch (err) {
-    console.error(`Error loading Ollama models: ${err}`);
+    logger.error(`Error loading Ollama models: ${err}`);
     return {};
   }
 };
 
-export const loadOllamaEmbeddingModels = async () => {
-  const ollamaApiEndpoint = getOllamaApiEndpoint();
+export const loadOllamaEmbeddingsModels = async () => {
+  const ollamaEndpoint = getOllamaApiEndpoint();
 
-  if (!ollamaApiEndpoint) return {};
+  if (!ollamaEndpoint) return {};
 
   try {
-    const res = await axios.get(`${ollamaApiEndpoint}/api/tags`, {
+    const response = await axios.get(`${ollamaEndpoint}/api/tags`, {
       headers: {
         'Content-Type': 'application/json',
       },
     });
 
-    const { models } = res.data;
+    const { models: ollamaModels } = response.data;
 
-    const embeddingModels: Record<string, EmbeddingModel> = {};
-
-    models.forEach((model: any) => {
-      embeddingModels[model.model] = {
+    const embeddingsModels = ollamaModels.reduce((acc, model) => {
+      acc[model.model] = {
         displayName: model.name,
         model: new OllamaEmbeddings({
-          baseUrl: ollamaApiEndpoint,
+          baseUrl: ollamaEndpoint,
           model: model.model,
         }),
       };
-    });
 
-    return embeddingModels;
+      return acc;
+    }, {});
+
+    return embeddingsModels;
   } catch (err) {
-    console.error(`Error loading Ollama embeddings models: ${err}`);
+    logger.error(`Error loading Ollama embeddings model: ${err}`);
     return {};
   }
 };

src/lib/providers/openai.ts

@@ -1,90 +1,89 @@
 import { ChatOpenAI, OpenAIEmbeddings } from '@langchain/openai';
-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',
-  },
-];
+import { getOpenaiApiKey } from '../../config';
+import logger from '../../utils/logger';
 
 export const loadOpenAIChatModels = async () => {
-  const openaiApiKey = getOpenaiApiKey();
+  const openAIApiKey = getOpenaiApiKey();
 
-  if (!openaiApiKey) return {};
+  if (!openAIApiKey) return {};
 
   try {
-    const chatModels: Record<string, ChatModel> = {};
-
-    openaiChatModels.forEach((model) => {
-      chatModels[model.key] = {
-        displayName: model.displayName,
+    const chatModels = {
+      'gpt-3.5-turbo': {
+        displayName: 'GPT-3.5 Turbo',
         model: new ChatOpenAI({
-          openAIApiKey: openaiApiKey,
-          modelName: model.key,
+          openAIApiKey,
+          modelName: 'gpt-3.5-turbo',
           temperature: 0.7,
-        }) as unknown as BaseChatModel,
-      };
-    });
+        }),
+      },
+      '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,
+        }),
+      },
+    };
 
     return chatModels;
   } catch (err) {
-    console.error(`Error loading OpenAI models: ${err}`);
+    logger.error(`Error loading OpenAI models: ${err}`);
     return {};
   }
 };
 
-export const loadOpenAIEmbeddingModels = async () => {
-  const openaiApiKey = getOpenaiApiKey();
+export const loadOpenAIEmbeddingsModels = async () => {
+  const openAIApiKey = getOpenaiApiKey();
 
-  if (!openaiApiKey) return {};
+  if (!openAIApiKey) return {};
 
   try {
-    const embeddingModels: Record<string, EmbeddingModel> = {};
-
-    openaiEmbeddingModels.forEach((model) => {
-      embeddingModels[model.key] = {
-        displayName: model.displayName,
+    const embeddingModels = {
+      'text-embedding-3-small': {
+        displayName: 'Text Embedding 3 Small',
         model: new OpenAIEmbeddings({
-          openAIApiKey: openaiApiKey,
-          modelName: model.key,
-        }) as unknown as Embeddings,
-      };
-    });
+          openAIApiKey,
+          modelName: 'text-embedding-3-small',
+        }),
+      },
+      'text-embedding-3-large': {
+        displayName: 'Text Embedding 3 Large',
+        model: new OpenAIEmbeddings({
+          openAIApiKey,
+          modelName: 'text-embedding-3-large',
+        }),
+      },
+    };
 
     return embeddingModels;
   } catch (err) {
-    console.error(`Error loading OpenAI embeddings models: ${err}`);
+    logger.error(`Error loading OpenAI embeddings model: ${err}`);
     return {};
   }
 };

src/lib/providers/transformers.ts

@@ -1,3 +1,4 @@
+import logger from '../../utils/logger';
 import { HuggingFaceTransformersEmbeddings } from '../huggingfaceTransformer';
 
 export const loadTransformersEmbeddingsModels = async () => {
@@ -25,7 +26,7 @@ export const loadTransformersEmbeddingsModels = async () => {
 
     return embeddingModels;
   } catch (err) {
-    console.error(`Error loading Transformers embeddings model: ${err}`);
+    logger.error(`Error loading Transformers embeddings model: ${err}`);
     return {};
   }
 };

src/lib/search.ts

@@ -0,0 +1,54 @@
+import axios from 'axios';
+import { config } from '../config';
+
+interface SearchOptions {
+  maxResults?: number;
+  type?: 'general' | 'news';
+  engines?: string[];
+}
+
+interface SearchResult {
+  url: string;
+  title: string;
+  content: string;
+  score?: number;
+}
+
+export async function searchWeb(
+  query: string,
+  options: SearchOptions = {}
+): Promise<SearchResult[]> {
+  const {
+    maxResults = 20,
+    type = 'general',
+    engines = ['google', 'bing', 'duckduckgo']
+  } = options;
+
+  try {
+    const response = await axios.get(`${config.search.searxngUrl || process.env.SEARXNG_URL}/search`, {
+      params: {
+        q: query,
+        format: 'json',
+        categories: type,
+        engines: engines.join(','),
+        limit: maxResults
+      }
+    });
+
+    if (!response.data || !response.data.results) {
+      console.error('Invalid response from SearxNG:', response.data);
+      return [];
+    }
+
+    return response.data.results.map((result: any) => ({
+      url: result.url,
+      title: result.title,
+      content: result.content || result.snippet || '',
+      score: result.score
+    }));
+
+  } catch (error) {
+    console.error('Search failed:', error);
+    throw error;
+  }
+} 

src/lib/search/index.ts

@@ -1,59 +0,0 @@
-import MetaSearchAgent from '@/lib/search/metaSearchAgent';
-import prompts from '../prompts';
-
-export 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,
-  }),
-};

src/lib/searxng.ts

@@ -1,48 +1,313 @@
 import axios from 'axios';
-import { getSearxngApiEndpoint } from './config';
+import * as cheerio from 'cheerio';
+import { createWorker } from 'tesseract.js';
+import { env } from '../config/env';
+import { OllamaService } from './services/ollamaService';
+import { BusinessData } from './types';
+import { db } from './services/databaseService';
+import { generateBusinessId } from './utils';
+import { extractContactFromHtml, extractCleanAddress } from './utils/scraper';
+import { GeocodingService } from './services/geocodingService';
+import { cleanAddress, formatPhoneNumber, cleanEmail, cleanDescription } from './utils/dataCleanup';
+import { CleanupService } from './services/cleanupService';
 
-interface SearxngSearchOptions {
-  categories?: string[];
-  engines?: string[];
-  language?: string;
-  pageno?: number;
+// Define interfaces used only in this file
+interface SearchResult {
+    url: string;
+    title: string;
+    content: string;
+    phone?: string;
+    email?: string;
+    address?: string;
+    website?: string;
+    rating?: number;
+    coordinates?: {
+        lat: number;
+        lng: number;
+    };
 }
 
-interface SearxngSearchResult {
-  title: string;
-  url: string;
-  img_src?: string;
-  thumbnail_src?: string;
-  thumbnail?: string;
-  content?: string;
-  author?: string;
-  iframe_src?: string;
+interface ContactInfo {
+    phone?: string;
+    email?: string;
+    address?: string;
+    description?: string;
+    openingHours?: string[];
 }
 
-export const searchSearxng = async (
-  query: string,
-  opts?: SearxngSearchOptions,
-) => {
-  const searxngURL = getSearxngApiEndpoint();
+// Export the main search function
+export async function searchBusinesses(
+    query: string,
+    options: { onProgress?: (status: string, progress: number) => void } = {}
+): Promise<BusinessData[]> {
+    try {
+        console.log('Processing search query:', query);
+        const [searchTerm, location] = query.split(' in ').map(s => s.trim());
+        if (!searchTerm || !location) {
+            throw new Error('Invalid search query format. Use: "search term in location"');
+        }
 
-  const url = new URL(`${searxngURL}/search?format=json`);
-  url.searchParams.append('q', query);
+        options.onProgress?.('Checking cache', 0);
 
-  if (opts) {
-    Object.keys(opts).forEach((key) => {
-      const value = opts[key as keyof SearxngSearchOptions];
-      if (Array.isArray(value)) {
-        url.searchParams.append(key, value.join(','));
-        return;
-      }
-      url.searchParams.append(key, value as string);
-    });
-  }
+        // Check cache first
+        const cacheKey = `search:${searchTerm}:${location}`;
+        let results = await db.getFromCache(cacheKey);
+        
+        if (!results) {
+            // Check database for existing businesses
+            console.log('Searching database for:', searchTerm, 'in', location);
+            const existingBusinesses = await db.searchBusinesses(searchTerm, location);
+            
+            // Start search immediately
+            console.log('Starting web search');
+            const searchPromise = performSearch(searchTerm, location, options);
+            
+            if (existingBusinesses.length > 0) {
+                console.log(`Found ${existingBusinesses.length} existing businesses`);
+                options.onProgress?.('Retrieved from database', 50);
+            }
 
-  const res = await axios.get(url.toString());
+            // Wait for new results
+            const newResults = await searchPromise;
+            console.log(`Got ${newResults.length} new results from search`);
+            
+            // Merge results, removing duplicates by ID
+            const allResults = [...existingBusinesses];
+            for (const result of newResults) {
+                if (!allResults.some(b => b.id === result.id)) {
+                    allResults.push(result);
+                }
+            }
+            
+            console.log(`Total unique results: ${allResults.length}`);
+            
+            // Cache combined results
+            await db.saveToCache(cacheKey, allResults, env.cache.durationHours * 60 * 60 * 1000);
+            
+            console.log(`Returning ${allResults.length} total results (${existingBusinesses.length} existing + ${newResults.length} new)`);
+            results = allResults;
+        }
 
-  const results: SearxngSearchResult[] = res.data.results;
-  const suggestions: string[] = res.data.suggestions;
+        // Clean all results using LLM
+        options.onProgress?.('Cleaning data', 75);
+        const cleanedResults = await CleanupService.cleanBusinessRecords(results);
 
-  return { results, suggestions };
-};
+        options.onProgress?.('Search complete', 100);
+        return cleanedResults;
+    } catch (error) {
+        console.error('Search error:', error);
+        return [];
+    }
+}
+
+async function performSearch(
+    searchTerm: string, 
+    location: string, 
+    options: any
+): Promise<BusinessData[]> {
+    const queries = [
+        searchTerm + ' ' + location,
+        searchTerm + ' business near ' + location,
+        searchTerm + ' services ' + location,
+        'local ' + searchTerm + ' ' + location
+    ];
+
+    options.onProgress?.('Searching multiple sources', 25);
+
+    let allResults: SearchResult[] = [];
+    const seenUrls = new Set<string>();
+
+    for (const q of queries) {
+        try {
+            const response = await axios.get(`${env.searxng.currentUrl}/search`, {
+                params: {
+                    q,
+                    format: 'json',
+                    engines: 'google,google_maps',
+                    language: 'en-US',
+                    time_range: '',
+                    safesearch: 1
+                }
+            });
+
+            if (response.data?.results) {
+                // Deduplicate results
+                const newResults = response.data.results.filter((result: SearchResult) => {
+                    if (seenUrls.has(result.url)) {
+                        return false;
+                    }
+                    seenUrls.add(result.url);
+                    return true;
+                });
+
+                console.log(`Found ${newResults.length} unique results from ${response.data.results[0]?.engine}`);
+                allResults = allResults.concat(newResults);
+            }
+        } catch (error) {
+            console.error(`Search failed for query "${q}":`, error);
+        }
+    }
+
+    options.onProgress?.('Processing results', 50);
+
+    const filteredResults = allResults.filter(isValidBusinessResult);
+    const processedResults = await processResults(filteredResults, location);
+
+    // Save results to database
+    for (const result of processedResults) {
+        await db.saveBusiness(result).catch(console.error);
+    }
+
+    options.onProgress?.('Search complete', 100);
+    return processedResults;
+}
+
+// Add other necessary functions (isValidBusinessResult, processResults, etc.)
+function isValidBusinessResult(result: SearchResult): boolean {
+    // Skip listing/directory pages and search results
+    const skipPatterns = [
+        'tripadvisor.com',
+        'yelp.com',
+        'opentable.com',
+        'restaurants-for-sale',
+        'guide.michelin.com',
+        'denver.org',
+        '/blog/',
+        '/maps/',
+        'search?',
+        'features/',
+        '/lists/',
+        'reddit.com',
+        'eater.com'
+    ];
+
+    if (skipPatterns.some(pattern => result.url.toLowerCase().includes(pattern))) {
+        console.log(`Skipping listing page: ${result.url}`);
+        return false;
+    }
+
+    // Must have a title
+    if (!result.title || result.title.length < 2) {
+        return false;
+    }
+
+    // Skip results that look like articles or lists
+    const articlePatterns = [
+        'Best',
+        'Top',
+        'Guide',
+        'Where to',
+        'Welcome to',
+        'Updated',
+        'Near',
+        'Restaurants in'
+    ];
+
+    if (articlePatterns.some(pattern => result.title.includes(pattern))) {
+        console.log(`Skipping article: ${result.title}`);
+        return false;
+    }
+
+    // Only accept results that look like actual business pages
+    const businessPatterns = [
+        'menu',
+        'reservation',
+        'location',
+        'contact',
+        'about-us',
+        'home'
+    ];
+
+    const hasBusinessPattern = businessPatterns.some(pattern => 
+        result.url.toLowerCase().includes(pattern) || 
+        result.content.toLowerCase().includes(pattern)
+    );
+
+    if (!hasBusinessPattern) {
+        console.log(`Skipping non-business page: ${result.url}`);
+        return false;
+    }
+
+    return true;
+}
+
+async function processResults(results: SearchResult[], location: string): Promise<BusinessData[]> {
+    const processedResults: BusinessData[] = [];
+    
+    // Get coordinates for the location
+    const locationGeo = await GeocodingService.geocode(location);
+    const defaultCoords = locationGeo || { lat: 39.7392, lng: -104.9903 };
+
+    for (const result of results) {
+        try {
+            // Extract contact info from webpage
+            const contactInfo = await extractContactFromHtml(result.url);
+            
+            // Create initial business record
+            const business: BusinessData = {
+                id: generateBusinessId(result),
+                name: cleanBusinessName(result.title),
+                phone: result.phone || contactInfo.phone || '',
+                email: result.email || contactInfo.email || '',
+                address: result.address || contactInfo.address || '',
+                rating: result.rating || 0,
+                website: result.website || result.url || '',
+                logo: '',
+                source: 'web',
+                description: result.content || contactInfo.description || '',
+                location: defaultCoords,
+                openingHours: contactInfo.openingHours
+            };
+
+            // Clean up the record using LLM
+            const cleanedBusiness = await CleanupService.cleanBusinessRecord(business);
+
+            // Get coordinates for cleaned address
+            if (cleanedBusiness.address) {
+                const addressGeo = await GeocodingService.geocode(cleanedBusiness.address);
+                if (addressGeo) {
+                    cleanedBusiness.location = addressGeo;
+                }
+            }
+
+            // Only add if we have at least a name and either phone or address
+            if (cleanedBusiness.name && (cleanedBusiness.phone || cleanedBusiness.address)) {
+                processedResults.push(cleanedBusiness);
+            }
+
+        } catch (error) {
+            console.error(`Error processing result ${result.title}:`, error);
+        }
+    }
+
+    return processedResults;
+}
+
+// Helper functions
+function cleanBusinessName(name: string): string {
+    // Remove common suffixes and prefixes
+    const cleanName = name
+        .replace(/^(The|A|An)\s+/i, '')
+        .replace(/\s+(-|–|—|:).*$/, '')
+        .replace(/\s*\([^)]*\)/g, '')
+        .trim();
+    
+    return cleanName;
+}
+
+async function getLocationCoordinates(address: string): Promise<{lat: number, lng: number}> {
+    // Implement geocoding here
+    // For now, return default coordinates for Denver
+    return { lat: 39.7392, lng: -104.9903 };
+}
+
+async function searchAndUpdateInBackground(searchTerm: string, location: string) {
+    try {
+        const results = await performSearch(searchTerm, location, {});
+        console.log(`Updated ${results.length} businesses in background`);
+    } catch (error) {
+        console.error('Background search error:', error);
+    }
+}
+
+// ... rest of the file remains the same

src/lib/services/businessCrawler.ts

@@ -0,0 +1,111 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { Cache } from '../utils/cache';
+import { RateLimiter } from '../utils/rateLimiter';
+
+interface CrawlResult {
+  mainContent: string;
+  contactInfo: string;
+  aboutInfo: string;
+  structuredData: any;
+}
+
+export class BusinessCrawler {
+  private cache: Cache<CrawlResult>;
+  private rateLimiter: RateLimiter;
+
+  constructor() {
+    this.cache = new Cache<CrawlResult>(60); // 1 hour cache
+    this.rateLimiter = new RateLimiter();
+  }
+
+  async crawlBusinessSite(url: string): Promise<CrawlResult> {
+    // Check cache first
+    const cached = this.cache.get(url);
+    if (cached) return cached;
+
+    await this.rateLimiter.waitForSlot();
+
+    try {
+      const mainPage = await this.fetchPage(url);
+      const $ = cheerio.load(mainPage);
+      
+      // Get all important URLs
+      const contactUrl = this.findContactPage($, url);
+      const aboutUrl = this.findAboutPage($, url);
+
+      // Crawl additional pages
+      const [contactPage, aboutPage] = await Promise.all([
+        contactUrl ? this.fetchPage(contactUrl) : '',
+        aboutUrl ? this.fetchPage(aboutUrl) : ''
+      ]);
+
+      // Extract structured data
+      const structuredData = this.extractStructuredData($);
+
+      const result = {
+        mainContent: $('body').text(),
+        contactInfo: contactPage,
+        aboutInfo: aboutPage,
+        structuredData
+      };
+
+      this.cache.set(url, result);
+      return result;
+    } catch (error) {
+      console.error(`Failed to crawl ${url}:`, error);
+      return {
+        mainContent: '',
+        contactInfo: '',
+        aboutInfo: '',
+        structuredData: {}
+      };
+    }
+  }
+
+  private async fetchPage(url: string): Promise<string> {
+    try {
+      const response = await axios.get(url, {
+        timeout: 10000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; BizSearch/1.0; +http://localhost:3000/about)',
+        }
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Failed to fetch ${url}:`, error);
+      return '';
+    }
+  }
+
+  private findContactPage($: cheerio.CheerioAPI, baseUrl: string): string | null {
+    const contactLinks = $('a[href*="contact"], a:contains("Contact")');
+    if (contactLinks.length > 0) {
+      const href = contactLinks.first().attr('href');
+      return href ? new URL(href, baseUrl).toString() : null;
+    }
+    return null;
+  }
+
+  private findAboutPage($: cheerio.CheerioAPI, baseUrl: string): string | null {
+    const aboutLinks = $('a[href*="about"], a:contains("About")');
+    if (aboutLinks.length > 0) {
+      const href = aboutLinks.first().attr('href');
+      return href ? new URL(href, baseUrl).toString() : null;
+    }
+    return null;
+  }
+
+  private extractStructuredData($: cheerio.CheerioAPI): any {
+    const structuredData: any[] = [];
+    $('script[type="application/ld+json"]').each((_, element) => {
+      try {
+        const data = JSON.parse($(element).html() || '{}');
+        structuredData.push(data);
+      } catch (error) {
+        console.error('Failed to parse structured data:', error);
+      }
+    });
+    return structuredData;
+  }
+}