Delete docsgpt_scanner.py

-Only for api_tool for now, if this solution works well then implementation for other tools is required
- Need to check api keys creation with the current proxies
- Show connection string example at creation
- locale needs updates for other languages

.devcontainer/Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.12-bookworm
+
+# Install Node.js 20.x
+RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install global npm packages
+RUN npm install -g husky vite
+
+# Create and activate Python virtual environment
+RUN python -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+WORKDIR /workspace

.devcontainer/devc-welcome.md

@@ -0,0 +1,49 @@
+# Welcome to DocsGPT Devcontainer
+
+Welcome to the DocsGPT development environment! This guide will help you get started quickly.
+
+## Starting Services
+
+To run DocsGPT, you need to start three main services: Flask (backend), Celery (task queue), and Vite (frontend). Here are the commands to start each service within the devcontainer:
+
+### Vite (Frontend)
+
+```bash
+cd frontend
+npm run dev -- --host
+```
+
+### Flask (Backend)
+
+```bash
+flask --app application/app.py run --host=0.0.0.0 --port=7091
+```
+
+### Celery (Task Queue)
+
+```bash
+celery -A application.app.celery worker -l INFO
+```
+
+## Github Codespaces Instructions
+
+### 1. Make Ports Public:
+
+Go to the "Ports" panel in Codespaces (usually located at the bottom of the VS Code window).
+
+For both port 5173 and 7091, right-click on the port and select "Make Public".
+
+![CleanShot 2025-02-12 at 09 46 14@2x](https://github.com/user-attachments/assets/00a34b16-a7ef-47af-9648-87a7e3008475)
+
+
+ ### 2. Update VITE_API_HOST:
+
+After making port 7091 public, copy the public URL provided by Codespaces for port 7091.
+
+Open the file frontend/.env.development.
+
+Find the line VITE_API_HOST=http://localhost:7091.
+
+Replace http://localhost:7091 with the public URL you copied from Codespaces.
+
+![CleanShot 2025-02-12 at 09 46 56@2x](https://github.com/user-attachments/assets/c472242f-1079-4cd8-bc0b-2d78db22b94c)

.devcontainer/devcontainer.json

@@ -0,0 +1,24 @@
+{
+	"name": "DocsGPT Dev Container",
+	"dockerComposeFile": ["docker-compose-dev.yaml", "docker-compose.override.yaml"],
+	"service": "dev",
+	"workspaceFolder": "/workspace",
+	"postCreateCommand": ".devcontainer/post-create-command.sh",
+	"forwardPorts": [7091, 5173, 6379, 27017],
+	"customizations": {
+	  "vscode": {
+		"extensions": [
+		  "ms-python.python",
+		  "ms-toolsai.jupyter",
+		  "esbenp.prettier-vscode",
+		  "dbaeumer.vscode-eslint"
+		]
+	  },
+	  "codespaces": {
+			"openFiles": [
+			".devcontainer/devc-welcome.md",
+			"CONTRIBUTING.md"
+			]
+		}
+	}
+  }

.devcontainer/docker-compose.override.yaml

@@ -0,0 +1,40 @@
+version: '3.8'
+
+services:
+  dev:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    volumes:
+      - ../:/workspace:cached
+    command: sleep infinity
+    depends_on:
+      redis:
+        condition: service_healthy
+      mongo:
+        condition: service_healthy
+    environment:
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/1
+      - MONGO_URI=mongodb://mongo:27017/docsgpt
+      - CACHE_REDIS_URL=redis://redis:6379/2
+    networks:
+      - default
+
+  redis:
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 30s
+      retries: 5
+
+  mongo:
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      interval: 5s
+      timeout: 30s
+      retries: 5
+
+networks:
+  default:
+    name: docsgpt-dev-network

.devcontainer/post-create-command.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -e  # Exit immediately if a command exits with a non-zero status
+
+if [ ! -f frontend/.env.development ]; then
+  cp -n .env-template frontend/.env.development || true # Assuming .env-template is in the root
+fi
+
+# Determine VITE_API_HOST based on environment
+if [ -n "$CODESPACES" ]; then
+  # Running in Codespaces
+  CODESPACE_NAME=$(echo "$CODESPACES" | cut -d'-' -f1) # Extract codespace name
+  PUBLIC_API_HOST="https://${CODESPACE_NAME}-7091.${GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN}"
+  echo "Setting VITE_API_HOST for Codespaces: $PUBLIC_API_HOST in frontend/.env.development"
+  sed -i "s|VITE_API_HOST=.*|VITE_API_HOST=$PUBLIC_API_HOST|" frontend/.env.development
+else
+  # Not running in Codespaces (local devcontainer)
+  DEFAULT_API_HOST="http://localhost:7091"
+  echo "Setting VITE_API_HOST for local dev: $DEFAULT_API_HOST in frontend/.env.development"
+  sed -i "s|VITE_API_HOST=.*|VITE_API_HOST=$DEFAULT_API_HOST|" frontend/.env.development
+fi
+
+
+mkdir -p model
+if [ ! -d model/all-mpnet-base-v2 ]; then
+    wget -q https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip -O model/mpnet-base-v2.zip
+    unzip -q model/mpnet-base-v2.zip -d model
+    rm model/mpnet-base-v2.zip
+fi
+pip install -r application/requirements.txt
+cd frontend
+npm install --include=dev

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: arc53

.github/dependabot.yml

@@ -8,12 +8,12 @@ updates:
   - package-ecosystem: "pip" # See documentation for possible values
     directory: "/application" # Location of package manifests
     schedule:
-      interval: "weekly"
+      interval: "daily"
   - package-ecosystem: "npm" # See documentation for possible values
     directory: "/frontend" # Location of package manifests
     schedule:
-      interval: "weekly"
+      interval: "daily"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "daily"

.github/workflows/bandit.yaml

@@ -0,0 +1,40 @@
+name: Bandit Security Scan
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  bandit_scan:
+    if: ${{ github.repository == 'arc53/DocsGPT' }}
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      actions: read
+      contents: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install bandit  # Bandit is needed for this action
+          if [ -f application/requirements.txt ]; then pip install -r application/requirements.txt; fi
+
+      - name: Run Bandit scan
+        uses: PyCQA/bandit-action@v1
+        with:
+          severity: medium
+          confidence: medium
+          targets: application/
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -5,20 +5,33 @@ on:
     types: [published]
 
 jobs:
-  deploy:
+  build:
     if: github.repository == 'arc53/DocsGPT'
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+            suffix: amd64
+          - platform: linux/arm64
+            runner: ubuntu-24.04-arm
+            suffix: arm64
+    runs-on: ${{ matrix.runner }}
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU
+      - name: Set up QEMU  # Only needed for emulation, not for native arm64 builds
+        if: matrix.platform == 'linux/arm64'
         uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
 
       - name: Login to DockerHub
         uses: docker/login-action@v3
@@ -33,15 +46,67 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push Docker images to docker.io and ghcr.io
+      - name: Build and push platform-specific images
         uses: docker/build-push-action@v6
         with:
           file: './application/Dockerfile'
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           context: ./application
           push: true
           tags: |
-            ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }},${{ secrets.DOCKER_USERNAME }}/docsgpt:latest
-            ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }},ghcr.io/${{ github.repository_owner }}/docsgpt:latest
+            ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }}-${{ matrix.suffix }}
+            ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }}-${{ matrix.suffix }}
+          provenance: false
+          sbom: false
           cache-from: type=registry,ref=${{ secrets.DOCKER_USERNAME }}/docsgpt:latest
           cache-to: type=inline
+
+  manifest:
+    if: github.repository == 'arc53/DocsGPT'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Login to ghcr.io
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push manifest for DockerHub
+        run: |
+          set -e
+          docker manifest create ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }} \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }}-amd64 \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }}
+          docker manifest create ${{ secrets.DOCKER_USERNAME }}/docsgpt:latest \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }}-amd64 \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ${{ secrets.DOCKER_USERNAME }}/docsgpt:latest
+
+      - name: Create and push manifest for ghcr.io
+        run: |
+          set -e
+          docker manifest create ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }} \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }}-amd64 \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }}
+          docker manifest create ghcr.io/${{ github.repository_owner }}/docsgpt:latest \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }}-amd64 \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ghcr.io/${{ github.repository_owner }}/docsgpt:latest

.github/workflows/cife.yml

@@ -5,20 +5,33 @@ on:
     types: [published]
 
 jobs:
-  deploy:
+  build:
     if: github.repository == 'arc53/DocsGPT'
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+            suffix: amd64
+          - platform: linux/arm64
+            runner: ubuntu-24.04-arm
+            suffix: arm64
+    runs-on: ${{ matrix.runner }}
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU
+      - name: Set up QEMU # Only needed for emulation, not for native arm64 builds
+        if: matrix.platform == 'linux/arm64'
         uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
 
       - name: Login to DockerHub
         uses: docker/login-action@v3
@@ -33,16 +46,67 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      # Runs a single command using the runners shell
-      - name: Build and push Docker images to docker.io and ghcr.io
+      - name: Build and push platform-specific images
         uses: docker/build-push-action@v6
         with:
           file: './frontend/Dockerfile'
-          platforms: linux/amd64, linux/arm64
+          platforms: ${{ matrix.platform }}
           context: ./frontend
           push: true
           tags: |
-            ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }},${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:latest
-            ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }},ghcr.io/${{ github.repository_owner }}/docsgpt-fe:latest
+            ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }}-${{ matrix.suffix }}
+            ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }}-${{ matrix.suffix }}
+          provenance: false
+          sbom: false
           cache-from: type=registry,ref=${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:latest
           cache-to: type=inline
+
+  manifest:
+    if: github.repository == 'arc53/DocsGPT'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Login to ghcr.io
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push manifest for DockerHub
+        run: |
+          set -e
+          docker manifest create ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }} \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }}-amd64 \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }}
+          docker manifest create ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:latest \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }}-amd64 \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:latest
+
+      - name: Create and push manifest for ghcr.io
+        run: |
+          set -e
+          docker manifest create ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }} \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }}-amd64 \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }}
+          docker manifest create ghcr.io/${{ github.repository_owner }}/docsgpt-fe:latest \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }}-amd64 \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt-fe:${{ github.event.release.tag_name }}-arm64
+          docker manifest push ghcr.io/${{ github.repository_owner }}/docsgpt-fe:latest

.github/workflows/docker-develop-build.yml

@@ -1,4 +1,4 @@
-name: Build and push DocsGPT Docker image for development
+name: Build and push multi-arch DocsGPT Docker image
 
 on:
   workflow_dispatch:
@@ -7,27 +7,36 @@ on:
       - main
 
 jobs:
-  deploy:
+  build:
     if: github.repository == 'arc53/DocsGPT'
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+            suffix: amd64
+          - platform: linux/arm64
+            runner: ubuntu-24.04-arm
+            suffix: arm64
+    runs-on: ${{ matrix.runner }}
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
 
       - name: Login to DockerHub
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
-
+      
       - name: Login to ghcr.io
         uses: docker/login-action@v3
         with:
@@ -35,15 +44,57 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push Docker images to docker.io and ghcr.io
+      - name: Build and push platform-specific images
         uses: docker/build-push-action@v6
         with:
           file: './application/Dockerfile'
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           context: ./application
           push: true
           tags: |
-            ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop
-            ghcr.io/${{ github.repository_owner }}/docsgpt:develop
+            ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop-${{ matrix.suffix }}
+            ghcr.io/${{ github.repository_owner }}/docsgpt:develop-${{ matrix.suffix }}
+          provenance: false
+          sbom: false
           cache-from: type=registry,ref=${{ secrets.DOCKER_USERNAME }}/docsgpt:develop
           cache-to: type=inline
+
+  manifest:
+    if: github.repository == 'arc53/DocsGPT'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      
+      - name: Login to ghcr.io
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+        
+      - name: Create and push manifest for DockerHub
+        run: |
+          docker manifest create ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop-amd64 \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop-arm64
+          docker manifest push ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop
+
+      - name: Create and push manifest for ghcr.io
+        run: |
+          docker manifest create ghcr.io/${{ github.repository_owner }}/docsgpt:develop \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt:develop-amd64 \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt:develop-arm64
+          docker manifest push ghcr.io/${{ github.repository_owner }}/docsgpt:develop

.github/workflows/docker-develop-fe-build.yml

@@ -7,20 +7,33 @@ on:
       - main
 
 jobs:
-  deploy:
+  build:
     if: github.repository == 'arc53/DocsGPT'
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+            suffix: amd64
+          - platform: linux/arm64
+            runner: ubuntu-24.04-arm
+            suffix: arm64
+    runs-on: ${{ matrix.runner }}
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU
+      - name: Set up QEMU # Only needed for emulation, not for native arm64 builds
+        if: matrix.platform == 'linux/arm64'
         uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
 
       - name: Login to DockerHub
         uses: docker/login-action@v3
@@ -35,15 +48,57 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push Docker images to docker.io and ghcr.io
+      - name: Build and push platform-specific images
         uses: docker/build-push-action@v6
         with:
           file: './frontend/Dockerfile'
-          platforms: linux/amd64
+          platforms: ${{ matrix.platform }}
           context: ./frontend
           push: true
           tags: |
-            ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop
-            ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop
+            ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop-${{ matrix.suffix }}
+            ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop-${{ matrix.suffix }}
+          provenance: false
+          sbom: false
           cache-from: type=registry,ref=${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop
           cache-to: type=inline
+
+  manifest:
+    if: github.repository == 'arc53/DocsGPT'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+          install: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Login to ghcr.io
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push manifest for DockerHub
+        run: |
+          docker manifest create ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop-amd64 \
+            --amend ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop-arm64
+          docker manifest push ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop
+
+      - name: Create and push manifest for ghcr.io
+        run: |
+          docker manifest create ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop-amd64 \
+            --amend ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop-arm64
+          docker manifest push ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop

.github/workflows/pytest.yml

@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.11"]
+        python-version: ["3.12"]
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
@@ -23,8 +23,8 @@ jobs:
         run: |
           python -m pytest --cov=application --cov-report=xml
       - name: Upload coverage reports to Codecov
-        if: github.event_name == 'pull_request' && matrix.python-version == '3.11'
-        uses: codecov/codecov-action@v4
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.12'
+        uses: codecov/codecov-action@v5
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 

.vscode/launch.json

@@ -11,6 +11,44 @@
       "skipFiles": [
         "<node_internals>/**"
       ]
+    },
+    {
+        "name": "Flask Debugger",
+        "type": "debugpy",
+        "request": "launch",
+        "module": "flask",
+        "env": {
+            "FLASK_APP": "application/app.py",
+            "PYTHONPATH": "${workspaceFolder}",
+            "FLASK_ENV": "development",
+            "FLASK_DEBUG": "1",
+            "FLASK_RUN_PORT": "7091",
+            "FLASK_RUN_HOST": "0.0.0.0"
+
+        },
+        "args": [
+            "run",
+            "--no-debugger"
+        ],
+        "cwd": "${workspaceFolder}",
+    },
+    {
+      "name": "Celery Debugger",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "celery",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}",
+      },
+      "args": [
+        "-A",
+        "application.app.celery",
+        "worker",
+        "-l",
+        "INFO",
+        "--pool=solo"
+      ],
+      "cwd": "${workspaceFolder}"
     }
   ]
 }

CONTRIBUTING.md

@@ -27,6 +27,7 @@ Before creating issues, please check out how the latest version of our app looks
 
 ### 👨‍💻 If you're interested in contributing code, here are some important things to know:
 
+For instructions on setting up a development environment, please refer to our [Development Deployment Guide](https://docs.docsgpt.cloud/Deploying/Development-Environment).
 
 Tech Stack Overview:
 
@@ -34,19 +35,40 @@ Tech Stack Overview:
 
 - 🖥 Backend: Developed in Python 🐍
 
-### 🌐 If you are looking to contribute to frontend (⚛️React, Vite):
+### 🌐 Frontend Contributions (⚛️ React, Vite)
 
-- The current frontend is being migrated from [`/application`](https://github.com/arc53/DocsGPT/tree/main/application) to [`/frontend`](https://github.com/arc53/DocsGPT/tree/main/frontend) with a new design, so please contribute to the new one.
-- Check out this [milestone](https://github.com/arc53/DocsGPT/milestone/1) and its issues.
-- The updated Figma design can be found [here](https://www.figma.com/file/OXLtrl1EAy885to6S69554/DocsGPT?node-id=0%3A1&t=hjWVuxRg9yi5YkJ9-1).
+*   The updated Figma design can be found [here](https://www.figma.com/file/OXLtrl1EAy885to6S69554/DocsGPT?node-id=0%3A1&t=hjWVuxRg9yi5YkJ9-1).  Please try to follow the guidelines.
+*   **Coding Style:** We follow a strict coding style enforced by ESLint and Prettier. Please ensure your code adheres to the configuration provided in our repository's `fronetend/.eslintrc.js` file.  We recommend configuring your editor with ESLint and Prettier to help with this.
+* **Component Structure:** Strive for small, reusable components.  Favor functional components and hooks over class components where possible.
+* **State Management** If you need to add stores, please use Redux.
 
-Please try to follow the guidelines.
+### 🖥 Backend Contributions (🐍 Python)
 
-### 🖥 If you are looking to contribute to Backend (🐍 Python):
-
-- Review our issues and contribute to [`/application`](https://github.com/arc53/DocsGPT/tree/main/application) or [`/scripts`](https://github.com/arc53/DocsGPT/tree/main/scripts) (please disregard old [`ingest_rst.py`](https://github.com/arc53/DocsGPT/blob/main/scripts/old/ingest_rst.py) [`ingest_rst_sphinx.py`](https://github.com/arc53/DocsGPT/blob/main/scripts/old/ingest_rst_sphinx.py) files; these will be deprecated soon).
+- Review our issues and contribute to [`/application`](https://github.com/arc53/DocsGPT/tree/main/application) 
 - All new code should be covered with unit tests ([pytest](https://github.com/pytest-dev/pytest)). Please find tests under [`/tests`](https://github.com/arc53/DocsGPT/tree/main/tests) folder.
 - Before submitting your Pull Request, ensure it can be queried after ingesting some test data.
+- **Coding Style:** We adhere to the [PEP 8](https://www.python.org/dev/peps/pep-0008/) style guide for Python code. We use `ruff` as our linter and code formatter.  Please ensure your code is formatted correctly and passes `ruff` checks before submitting.
+- **Type Hinting:**  Please use type hints for all function arguments and return values. This improves code readability and helps catch errors early.  Example:
+
+    ```python
+    def my_function(name: str, count: int) -> list[str]:
+        ...
+    ```
+- **Docstrings:**  All functions and classes should have docstrings explaining their purpose, parameters, and return values.  We prefer the [Google style docstrings](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html). Example:
+
+    ```python
+    def my_function(name: str, count: int) -> list[str]:
+        """Does something with a name and a count.
+
+        Args:
+            name: The name to use.
+            count: The number of times to do it.
+
+        Returns:
+            A list of strings.
+        """
+        ...
+    ```
   
 ### Testing
 

HACKTOBERFEST.md

@@ -1,41 +0,0 @@
-# **🎉 Join the Hacktoberfest with DocsGPT and win a Free T-shirt and other prizes! 🎉**
-
-Welcome, contributors! We're excited to announce that DocsGPT is participating in Hacktoberfest. Get involved by submitting meaningful pull requests.
-
-All contributors with accepted PRs will receive a cool Holopin! 🤩 (Watch out for a reply in your PR to collect it).
-
-### 🏆 Top 50 contributors will receive a special T-shirt
-
-### 🏆 [LLM Document analysis by LexEU competition](https://github.com/arc53/DocsGPT/blob/main/lexeu-competition.md): 
-A separate competition is available for those who submit new retrieval / workflow method that will analyze a Document using EU laws.
-With 200$, 100$, 50$ prize for 1st, 2nd and 3rd place respectively.
-You can find more information [here](https://github.com/arc53/DocsGPT/blob/main/lexeu-competition.md)
-
-## 📜 Here's How to Contribute:
-```text
-🛠️ Code: This is the golden ticket! Make meaningful contributions through PRs.
-
-🧩 API extension: Build an app utilising DocsGPT API. We prefer submissions that showcase original ideas and turn the API into an AI agent.
-They can be a completely separate repos. 
-For example: 
-https://github.com/arc53/tg-bot-docsgpt-extenstion or 
-https://github.com/arc53/DocsGPT-cli
-
-Non-Code Contributions:
-
-📚 Wiki: Improve our documentation, create a guide or change existing documentation.
-
-🖥️ Design: Improve the UI/UX or design a new feature.
-
-📝 Blogging or Content Creation: Write articles or create videos to showcase DocsGPT or highlight your contributions!
-```
-
-### 📝 Guidelines for Pull Requests:
-- Familiarize yourself with the current contributions and our [Roadmap](https://github.com/orgs/arc53/projects/2).
-- Before contributing we highly advise that you check existing [issues](https://github.com/arc53/DocsGPT/issues) or [create](https://github.com/arc53/DocsGPT/issues/new/choose) an issue and wait to get assigned.
-- Once you are finished with your contribution, please fill in this [form](https://airtable.com/appikMaJwdHhC1SDP/pagoblCJ9W29wf6Hf/form).
-- Refer to the [Documentation](https://docs.docsgpt.cloud/).
-- Feel free to join our [Discord](https://discord.gg/n5BX8dh8rU) server. We're here to help newcomers, so don't hesitate to jump in! Join us [here](https://discord.gg/n5BX8dh8rU).
-  
-Thank you very much for considering contributing to DocsGPT during Hacktoberfest! 🙏 Your contributions (not just simple typos) could earn you a stylish new t-shirt and other prizes as a token of our appreciation. 🎁 Join us, and let's code together! 🚀
-

README.md

@@ -3,13 +3,11 @@
 </h1>
 
 <p align="center">
-  <strong>Open-Source Documentation Assistant</strong>
+  <strong>Open-Source RAG Assistant</strong>
 </p>
 
 <p align="left">
-  <strong><a href="https://www.docsgpt.cloud/">DocsGPT</a></strong> is a cutting-edge open-source solution that streamlines the process of finding information in the project documentation. With its integration of the powerful <strong>GPT</strong> models, developers can easily ask questions about a project and receive accurate answers.
-  
-Say goodbye to time-consuming manual searches, and let <strong><a href="https://www.docsgpt.cloud/">DocsGPT</a></strong> help you quickly find the information you need. Try it out and see how it revolutionizes your project documentation experience. Contribute to its development and be a part of the future of AI-powered assistance.
+  <strong><a href="https://www.docsgpt.cloud/">DocsGPT</a></strong> is an open-source genAI tool that helps users get reliable answers from any knowledge source, while avoiding hallucinations. It enables quick and reliable information retrieval, with tooling and agentic system capability built in.
 </p>
 
 <div align="center">
@@ -17,178 +15,126 @@ Say goodbye to time-consuming manual searches, and let <strong><a href="https://
   <a href="https://github.com/arc53/DocsGPT">![link to main GitHub showing Stars number](https://img.shields.io/github/stars/arc53/docsgpt?style=social)</a>
   <a href="https://github.com/arc53/DocsGPT">![link to main GitHub showing Forks number](https://img.shields.io/github/forks/arc53/docsgpt?style=social)</a>
   <a href="https://github.com/arc53/DocsGPT/blob/main/LICENSE">![link to license file](https://img.shields.io/github/license/arc53/docsgpt)</a>
+  <a href="https://www.bestpractices.dev/projects/9907"><img src="https://www.bestpractices.dev/projects/9907/badge"></a>
   <a href="https://discord.gg/n5BX8dh8rU">![link to discord](https://img.shields.io/discord/1070046503302877216)</a>
   <a href="https://twitter.com/docsgptai">![X (formerly Twitter) URL](https://img.shields.io/twitter/follow/docsgptai)</a>
 
- 
+  <a href="https://docs.docsgpt.cloud/quickstart">⚡️ Quickstart</a> • <a href="https://app.docsgpt.cloud/">☁️ Cloud Version</a> • <a href="https://discord.gg/n5BX8dh8rU">💬 Discord</a>
+  <br>
+  <a href="https://docs.docsgpt.cloud/">📖 Documentation</a> • <a href="https://github.com/arc53/DocsGPT/blob/main/CONTRIBUTING.md">👫 Contribute</a> • <a href="https://blog.docsgpt.cloud/">🗞 Blog</a>
+  <br>
+
 </div>
+<div align="center">
+<img src="https://d3dg1063dc54p9.cloudfront.net/videos/demov7.gif" alt="video-example-of-docs-gpt" width="800" height="450">
+</div>
+<h3 align="left">
+  <strong>Key Features:</strong>
+</h3>
+<ul align="left">
+    <li><strong>🗂️ Wide Format Support:</strong> Reads PDF, DOCX, CSV, XLSX, EPUB, MD, RST, HTML, MDX, JSON, PPTX, and images.</li>
+    <li><strong>🌐 Web & Data Integration:</strong> Ingests from URLs, sitemaps, Reddit, GitHub and web crawlers.</li>
+    <li><strong>✅ Reliable Answers:</strong> Get accurate, hallucination-free responses with source citations viewable in a clean UI.</li>
+    <li><strong>🔑 Streamlined API Keys:</strong>  Generate keys linked to your settings, documents, and models, simplifying chatbot and integration setup.</li>
+    <li><strong>🔗 Actionable Tooling:</strong> Connect to APIs, tools, and other services to enable LLM actions.</li>
+    <li><strong>🧩 Pre-built Integrations:</strong> Use readily available HTML/React chat widgets, search tools, Discord/Telegram bots, and more.</li>
+    <li><strong>🔌 Flexible Deployment:</strong> Works with major LLMs (OpenAI, Google, Anthropic) and local models (Ollama, llama_cpp).</li>
+    <li><strong>🏢 Secure & Scalable:</strong> Run privately and securely with Kubernetes support, designed for enterprise-grade reliability.</li>
+</ul>
+
+## Roadmap
+
+- [x] Full GoogleAI compatibility (Jan 2025)
+- [x] Add tools (Jan 2025)
+- [x] Manually updating chunks in the app UI (Feb 2025)
+- [x] Devcontainer for easy development (Feb 2025)
+- [ ] Anthropic Tool compatibility
+- [ ] Add triggerable actions / tools (webhook)
+- [ ] Add OAuth 2.0 authentication for tools and sources
+- [ ] Chatbots menu re-design to handle tools, scheduling, and more
+
+You can find our full roadmap [here](https://github.com/orgs/arc53/projects/2). Please don't hesitate to contribute or create issues, it helps us improve DocsGPT!
 
 ### Production Support / Help for Companies:
 
 We're eager to provide personalized assistance when deploying your DocsGPT to a live environment.
 
-[Book a Meeting :wave:](https://cal.com/arc53/docsgpt-demo-b2b)⁠
+[Get a Demo :wave:](https://www.docsgpt.cloud/contact)⁠
 
-[Send Email :email:](mailto:contact@arc53.com?subject=DocsGPT%20support%2Fsolutions)
+[Send Email :email:](mailto:support@docsgpt.cloud?subject=DocsGPT%20support%2Fsolutions)
 
+## Join the Lighthouse Program 🌟
 
-<img src="https://github.com/user-attachments/assets/9a1f21de-7a15-4e42-9424-70d22ba5a913" alt="video-example-of-docs-gpt" width="1000" height="500">
+Calling all developers and GenAI innovators! The **DocsGPT Lighthouse Program** connects technical leaders actively deploying or extending DocsGPT in real-world scenarios. Collaborate directly with our team to shape the roadmap, access priority support, and build enterprise-ready solutions with exclusive community insights.  
 
-## Roadmap
+[Learn More & Apply →](https://docs.google.com/forms/d/1KAADiJinUJ8EMQyfTXUIGyFbqINNClNR3jBNWq7DgTE)
 
-You can find our roadmap [here](https://github.com/orgs/arc53/projects/2). Please don't hesitate to contribute or create issues, it helps us improve DocsGPT!
-
-## Our Open-Source Models Optimized for DocsGPT:
-
-| Name                                                                  | Base Model  | Requirements (or similar) |
-| --------------------------------------------------------------------- | ----------- | ------------------------- |
-| [Docsgpt-7b-mistral](https://huggingface.co/Arc53/docsgpt-7b-mistral)   | Mistral-7b   | 1xA10G gpu                |
-| [Docsgpt-14b](https://huggingface.co/Arc53/docsgpt-14b)               | llama-2-14b | 2xA10 gpu's               |
-| [Docsgpt-40b-falcon](https://huggingface.co/Arc53/docsgpt-40b-falcon) | falcon-40b  | 8xA10G gpu's              |
-
-If you don't have enough resources to run it, you can use bitsnbytes to quantize.
-
-## End to End AI Framework for Information Retrieval
-
-![Architecture chart](https://github.com/user-attachments/assets/fc6a7841-ddfc-45e6-b5a0-d05fe648cbe2)
-
-## Useful Links
-
-- :mag: :fire: [Cloud Version](https://app.docsgpt.cloud/)
-
-- :speech_balloon: :tada: [Join our Discord](https://discord.gg/n5BX8dh8rU)
-
-- :books: :sunglasses: [Guides](https://docs.docsgpt.cloud/)
-
-- :couple: [Interested in contributing?](https://github.com/arc53/DocsGPT/blob/main/CONTRIBUTING.md)
-
-- :file_folder: :rocket: [How to use any other documentation](https://docs.docsgpt.cloud/Guides/How-to-train-on-other-documentation)
-
-- :house: :closed_lock_with_key: [How to host it locally (so all data will stay on-premises)](https://docs.docsgpt.cloud/Guides/How-to-use-different-LLM)
-
-## Project Structure
-
-- Application - Flask app (main application).
-
-- Extensions - Chrome extension.
-
-- Scripts - Script that creates similarity search index for other libraries.
-
-- Frontend - Frontend uses <a href="https://vitejs.dev/">Vite</a> and <a href="https://react.dev/">React</a>.
 
 ## QuickStart
 
 > [!Note]
 > Make sure you have [Docker](https://docs.docker.com/engine/install/) installed
 
-On Mac OS or Linux, write:
+A more detailed [Quickstart](https://docs.docsgpt.cloud/quickstart) is available in our documentation
 
-`./setup.sh`
+1. **Clone the repository:**
 
-It will install all the dependencies and allow you to download the local model, use OpenAI or use our LLM API.
-
-Otherwise, refer to this Guide for Windows:
-
-1. Download and open this repository with `git clone https://github.com/arc53/DocsGPT.git`
-2. Create a `.env` file in your root directory and set the env variables and `VITE_API_STREAMING` to true or false, depending on whether you want streaming answers or not.
-   It should look like this inside:
-
-   ```
-   LLM_NAME=[docsgpt or openai or others] 
-   VITE_API_STREAMING=true
-   API_KEY=[if LLM_NAME is openai]
+   ```bash
+   git clone https://github.com/arc53/DocsGPT.git
+   cd DocsGPT
    ```
 
-   See optional environment variables in the [/.env-template](https://github.com/arc53/DocsGPT/blob/main/.env-template) and [/application/.env_sample](https://github.com/arc53/DocsGPT/blob/main/application/.env_sample) files.
+**For macOS and Linux:**
 
-3. Run [./run-with-docker-compose.sh](https://github.com/arc53/DocsGPT/blob/main/run-with-docker-compose.sh).
-4. Navigate to http://localhost:5173/.
+2. **Run the setup script:**
 
-To stop, just run `Ctrl + C`.
+   ```bash
+   ./setup.sh
+   ```
 
-## Development Environments
+This interactive script will guide you through setting up DocsGPT. It offers four options: using the public API, running locally, connecting to a local inference engine, or using a cloud API provider.  The script will automatically configure your `.env` file and handle necessary downloads and installations based on your chosen option.
 
-### Spin up Mongo and Redis
+**For Windows:**
 
-For development, only two containers are used from [docker-compose.yaml](https://github.com/arc53/DocsGPT/blob/main/docker-compose.yaml) (by deleting all services except for Redis and Mongo).
-See file [docker-compose-dev.yaml](./docker-compose-dev.yaml).
+2. **Follow the Docker Deployment Guide:**
 
-Run
+   Please refer to the [Docker Deployment documentation](https://docs.docsgpt.cloud/Deploying/Docker-Deploying) for detailed step-by-step instructions on setting up DocsGPT using Docker. 
 
+**Navigate to http://localhost:5173/**
+
+To stop DocsGPT, open a terminal in the `DocsGPT` directory and run:
+
+```bash
+docker compose -f deployment/docker-compose.yaml down
 ```
-docker compose -f docker-compose-dev.yaml build
-docker compose -f docker-compose-dev.yaml up -d
-```
-
-### Run the Backend
+(or use the specific `docker compose down` command shown after running `setup.sh`).
 
 > [!Note]
-> Make sure you have Python 3.10 or 3.11 installed.
-
-1. Export required environment variables or prepare a `.env` file in the project folder:
-   - Copy [.env-template](https://github.com/arc53/DocsGPT/blob/main/application/.env-template) and create `.env`.
-
-(check out [`application/core/settings.py`](application/core/settings.py) if you want to see more config options.)
-
-2. (optional) Create a Python virtual environment:
-   You can follow the [Python official documentation](https://docs.python.org/3/tutorial/venv.html) for virtual environments.
-
-a) On Mac OS and Linux
-
-```commandline
-python -m venv venv
-. venv/bin/activate
-```
-
-b) On Windows
-
-```commandline
-python -m venv venv
- venv/Scripts/activate
-```
-
-3. Download embedding model and save it in the `model/` folder:
-You can use the script below, or download it manually from [here](https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip), unzip it and save it in the `model/` folder.
-
-```commandline
-wget https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip
-unzip mpnet-base-v2.zip -d model
-rm mpnet-base-v2.zip
-```
-
-4. Install dependencies for the backend:
-
-```commandline
-pip install -r application/requirements.txt
-```
-
-5. Run the app using `flask --app application/app.py run --host=0.0.0.0 --port=7091`.
-6. Start worker with `celery -A application.app.celery worker -l INFO`.
-
-### Start Frontend
-
-> [!Note]
-> Make sure you have Node version 16 or higher.
-
-1. Navigate to the [/frontend](https://github.com/arc53/DocsGPT/tree/main/frontend) folder.
-2. Install the required packages `husky` and `vite` (ignore if already installed).
-
-```commandline
-npm install husky -g
-npm install vite -g
-```
-
-3. Install dependencies by running `npm install --include=dev`.
-4. Run the app using `npm run dev`.
+> For development environment setup instructions, please refer to the [Development Environment Guide](https://docs.docsgpt.cloud/Deploying/Development-Environment).
 
 ## Contributing
 
 Please refer to the [CONTRIBUTING.md](CONTRIBUTING.md) file for information about how to get involved. We welcome issues, questions, and pull requests.
 
+## Architecture
+
+![Architecture chart](https://github.com/user-attachments/assets/fc6a7841-ddfc-45e6-b5a0-d05fe648cbe2)
+
+## Project Structure
+
+- Application - Flask app (main application).
+
+- Extensions - Extensions, like react widget or discord bot.
+
+- Frontend - Frontend uses <a href="https://vitejs.dev/">Vite</a> and <a href="https://react.dev/">React</a>.
+
+- Scripts - Miscellaneous scripts.
+
 ## Code Of Conduct
 
 We as members, contributors, and leaders, pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. Please refer to the [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) file for more information about contributing.
 
+
 ## Many Thanks To Our Contributors⚡
 
 <a href="https://github.com/arc53/DocsGPT/graphs/contributors" alt="View Contributors">

application/Dockerfile

@@ -6,21 +6,20 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && \
     apt-get install -y software-properties-common && \
     add-apt-repository ppa:deadsnakes/ppa && \
-# Install necessary packages and Python
     apt-get update && \
-    apt-get install -y --no-install-recommends gcc wget unzip libc6-dev python3.11 python3.11-distutils python3.11-venv && \
+    apt-get install -y --no-install-recommends gcc wget unzip libc6-dev python3.12 python3.12-venv && \
     rm -rf /var/lib/apt/lists/* 
 
 # Verify Python installation and setup symlink
-RUN if [ -f /usr/bin/python3.11 ]; then \
-        ln -s /usr/bin/python3.11 /usr/bin/python; \
+RUN if [ -f /usr/bin/python3.12 ]; then \
+        ln -s /usr/bin/python3.12 /usr/bin/python; \
     else \
-        echo "Python 3.11 not found"; exit 1; \
+        echo "Python 3.12 not found"; exit 1; \
     fi
 
 # Download and unzip the model
 RUN wget https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip && \
-    unzip mpnet-base-v2.zip -d model && \
+    unzip mpnet-base-v2.zip -d models && \
     rm mpnet-base-v2.zip
 
 # Install Rust
@@ -33,7 +32,7 @@ RUN apt-get remove --purge -y wget unzip && apt-get autoremove -y && rm -rf /var
 COPY requirements.txt .
 
 # Setup Python virtual environment
-RUN python3.11 -m venv /venv
+RUN python3.12 -m venv /venv
 
 # Activate virtual environment and install Python packages
 ENV PATH="/venv/bin:$PATH"
@@ -49,9 +48,8 @@ FROM ubuntu:24.04 as final
 RUN apt-get update && \
     apt-get install -y software-properties-common && \
     add-apt-repository ppa:deadsnakes/ppa && \
-# Install Python
-    apt-get update && apt-get install -y --no-install-recommends python3.11 && \
-    ln -s /usr/bin/python3.11 /usr/bin/python && \
+    apt-get update && apt-get install -y --no-install-recommends python3.12 && \
+    ln -s /usr/bin/python3.12 /usr/bin/python && \
     rm -rf /var/lib/apt/lists/*
 
 # Set working directory
@@ -63,7 +61,8 @@ RUN groupadd -r appuser && \
 
 # Copy the virtual environment and model from the builder stage
 COPY --from=builder /venv /venv
-COPY --from=builder /model /app/model
+
+COPY --from=builder /models /app/models
 
 # Copy your application code
 COPY . /app/application

application/agents/agent_creator.py

@@ -0,0 +1,17 @@
+from application.agents.classic_agent import ClassicAgent
+
+
+class AgentCreator:
+    agents = {
+        "classic": ClassicAgent,
+    }
+
+    @classmethod
+    def create_agent(cls, type, *args, **kwargs):
+        agent_class = cls.agents.get(type.lower())
+        if not agent_class:
+            raise ValueError(f"No agent class found for type {type}")
+        config = kwargs.pop('config', None)
+        if isinstance(config, dict) and 'proxy_id' in config and 'proxy_id' not in kwargs:
+            kwargs['proxy_id'] = config['proxy_id']
+        return agent_class(*args, **kwargs)

application/agents/base.py

@@ -0,0 +1,161 @@
+from typing import Dict, Generator
+
+from application.agents.llm_handler import get_llm_handler
+from application.agents.tools.tool_action_parser import ToolActionParser
+from application.agents.tools.tool_manager import ToolManager
+
+from application.core.mongo_db import MongoDB
+from application.llm.llm_creator import LLMCreator
+
+
+class BaseAgent:
+    def __init__(
+        self,
+        endpoint,
+        llm_name,
+        gpt_model,
+        api_key,
+        user_api_key=None,
+        decoded_token=None,
+        proxy_id=None,
+    ):
+        self.endpoint = endpoint
+        self.llm = LLMCreator.create_llm(
+            llm_name,
+            api_key=api_key,
+            user_api_key=user_api_key,
+            decoded_token=decoded_token,
+        )
+        self.llm_handler = get_llm_handler(llm_name)
+        self.gpt_model = gpt_model
+        self.tools = []
+        self.tool_config = {}
+        self.tool_calls = []
+        self.proxy_id = proxy_id
+
+    def gen(self, *args, **kwargs) -> Generator[Dict, None, None]:
+        raise NotImplementedError('Method "gen" must be implemented in the child class')
+
+    def _get_user_tools(self, user="local"):
+        mongo = MongoDB.get_client()
+        db = mongo["docsgpt"]
+        user_tools_collection = db["user_tools"]
+        user_tools = user_tools_collection.find({"user": user, "status": True})
+        user_tools = list(user_tools)
+        tools_by_id = {str(tool["_id"]): tool for tool in user_tools}
+        if hasattr(self, 'proxy_id') and self.proxy_id:
+            for tool_id, tool in tools_by_id.items():
+                if 'config' not in tool:
+                    tool['config'] = {}
+                tool['config']['proxy_id'] = self.proxy_id
+        return tools_by_id
+
+    def _build_tool_parameters(self, action):
+        params = {"type": "object", "properties": {}, "required": []}
+        for param_type in ["query_params", "headers", "body", "parameters"]:
+            if param_type in action and action[param_type].get("properties"):
+                for k, v in action[param_type]["properties"].items():
+                    if v.get("filled_by_llm", True):
+                        params["properties"][k] = {
+                            key: value
+                            for key, value in v.items()
+                            if key != "filled_by_llm" and key != "value"
+                        }
+
+                        params["required"].append(k)
+        return params
+
+    def _prepare_tools(self, tools_dict):
+        self.tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": f"{action['name']}_{tool_id}",
+                    "description": action["description"],
+                    "parameters": self._build_tool_parameters(action),
+                },
+            }
+            for tool_id, tool in tools_dict.items()
+            if (
+                (tool["name"] == "api_tool" and "actions" in tool.get("config", {}))
+                or (tool["name"] != "api_tool" and "actions" in tool)
+            )
+            for action in (
+                tool["config"]["actions"].values()
+                if tool["name"] == "api_tool"
+                else tool["actions"]
+            )
+            if action.get("active", True)
+        ]
+
+    def _execute_tool_action(self, tools_dict, call):
+        parser = ToolActionParser(self.llm.__class__.__name__)
+        tool_id, action_name, call_args = parser.parse_args(call)
+
+        tool_data = tools_dict[tool_id]
+        action_data = (
+            tool_data["config"]["actions"][action_name]
+            if tool_data["name"] == "api_tool"
+            else next(
+                action
+                for action in tool_data["actions"]
+                if action["name"] == action_name
+            )
+        )
+
+        query_params, headers, body, parameters = {}, {}, {}, {}
+        param_types = {
+            "query_params": query_params,
+            "headers": headers,
+            "body": body,
+            "parameters": parameters,
+        }
+
+        for param_type, target_dict in param_types.items():
+            if param_type in action_data and action_data[param_type].get("properties"):
+                for param, details in action_data[param_type]["properties"].items():
+                    if param not in call_args and "value" in details:
+                        target_dict[param] = details["value"]
+
+        for param, value in call_args.items():
+            for param_type, target_dict in param_types.items():
+                if param_type in action_data and param in action_data[param_type].get(
+                    "properties", {}
+                ):
+                    target_dict[param] = value
+
+        tm = ToolManager(config={})
+        tool = tm.load_tool(
+            tool_data["name"],
+            tool_config=(
+                {
+                    "url": tool_data["config"]["actions"][action_name]["url"],
+                    "method": tool_data["config"]["actions"][action_name]["method"],
+                    "headers": headers,
+                    "query_params": query_params,
+                    "proxy_id": self.proxy_id,
+                }
+                if tool_data["name"] == "api_tool"
+                else tool_data["config"]
+            ),
+        )
+        if tool_data["name"] == "api_tool":
+            print(
+                f"Executing api: {action_name} with query_params: {query_params}, headers: {headers}, body: {body}"
+            )
+            result = tool.execute_action(action_name, **body)
+        else:
+            print(f"Executing tool: {action_name} with args: {call_args}")
+            result = tool.execute_action(action_name, **parameters)
+        call_id = getattr(call, "id", None)
+
+        tool_call_data = {
+            "tool_name": tool_data["name"],
+            "call_id": call_id if call_id is not None else "None",
+            "action_name": f"{action_name}_{tool_id}",
+            "arguments": call_args,
+            "result": result,
+        }
+        self.tool_calls.append(tool_call_data)
+
+        return result, call_id

application/agents/classic_agent.py

@@ -0,0 +1,141 @@
+import uuid
+from typing import Dict, Generator
+
+from application.agents.base import BaseAgent
+from application.logging import build_stack_data, log_activity, LogContext
+
+from application.retriever.base import BaseRetriever
+
+
+class ClassicAgent(BaseAgent):
+    def __init__(
+        self,
+        endpoint,
+        llm_name,
+        gpt_model,
+        api_key,
+        user_api_key=None,
+        prompt="",
+        chat_history=None,
+        decoded_token=None,
+        proxy_id=None,
+    ):
+        super().__init__(
+            endpoint, llm_name, gpt_model, api_key, user_api_key, decoded_token, proxy_id
+        )
+        self.user = decoded_token.get("sub")
+        self.prompt = prompt
+        self.chat_history = chat_history if chat_history is not None else []
+
+    @log_activity()
+    def gen(
+        self, query: str, retriever: BaseRetriever, log_context: LogContext = None
+    ) -> Generator[Dict, None, None]:
+        yield from self._gen_inner(query, retriever, log_context)
+
+    def _gen_inner(
+        self, query: str, retriever: BaseRetriever, log_context: LogContext
+    ) -> Generator[Dict, None, None]:
+        retrieved_data = self._retriever_search(retriever, query, log_context)
+
+        docs_together = "\n".join([doc["text"] for doc in retrieved_data])
+        p_chat_combine = self.prompt.replace("{summaries}", docs_together)
+        messages_combine = [{"role": "system", "content": p_chat_combine}]
+
+        if len(self.chat_history) > 0:
+            for i in self.chat_history:
+                if "prompt" in i and "response" in i:
+                    messages_combine.append({"role": "user", "content": i["prompt"]})
+                    messages_combine.append(
+                        {"role": "assistant", "content": i["response"]}
+                    )
+                if "tool_calls" in i:
+                    for tool_call in i["tool_calls"]:
+                        call_id = tool_call.get("call_id")
+                        if call_id is None or call_id == "None":
+                            call_id = str(uuid.uuid4())
+
+                        function_call_dict = {
+                            "function_call": {
+                                "name": tool_call.get("action_name"),
+                                "args": tool_call.get("arguments"),
+                                "call_id": call_id,
+                            }
+                        }
+                        function_response_dict = {
+                            "function_response": {
+                                "name": tool_call.get("action_name"),
+                                "response": {"result": tool_call.get("result")},
+                                "call_id": call_id,
+                            }
+                        }
+
+                        messages_combine.append(
+                            {"role": "assistant", "content": [function_call_dict]}
+                        )
+                        messages_combine.append(
+                            {"role": "tool", "content": [function_response_dict]}
+                        )
+        messages_combine.append({"role": "user", "content": query})
+
+        tools_dict = self._get_user_tools(self.user)
+        self._prepare_tools(tools_dict)
+
+        resp = self._llm_gen(messages_combine, log_context)
+
+        if isinstance(resp, str):
+            yield {"answer": resp}
+            return
+        if (
+            hasattr(resp, "message")
+            and hasattr(resp.message, "content")
+            and resp.message.content is not None
+        ):
+            yield {"answer": resp.message.content}
+            return
+
+        resp = self._llm_handler(resp, tools_dict, messages_combine, log_context)
+
+        if isinstance(resp, str):
+            yield {"answer": resp}
+        elif (
+            hasattr(resp, "message")
+            and hasattr(resp.message, "content")
+            and resp.message.content is not None
+        ):
+            yield {"answer": resp.message.content}
+        else:
+            completion = self.llm.gen_stream(
+                model=self.gpt_model, messages=messages_combine, tools=self.tools
+            )
+            for line in completion:
+                if isinstance(line, str):
+                    yield {"answer": line}
+
+        yield {"sources": retrieved_data}
+        yield {"tool_calls": self.tool_calls.copy()}
+
+    def _retriever_search(self, retriever, query, log_context):
+        retrieved_data = retriever.search(query)
+        if log_context:
+            data = build_stack_data(retriever, exclude_attributes=["llm"])
+            log_context.stacks.append({"component": "retriever", "data": data})
+        return retrieved_data
+
+    def _llm_gen(self, messages_combine, log_context):
+        resp = self.llm.gen_stream(
+            model=self.gpt_model, messages=messages_combine, tools=self.tools
+        )
+        if log_context:
+            data = build_stack_data(self.llm)
+            log_context.stacks.append({"component": "llm", "data": data})
+        return resp
+
+    def _llm_handler(self, resp, tools_dict, messages_combine, log_context):
+        resp = self.llm_handler.handle_response(
+            self, resp, tools_dict, messages_combine
+        )
+        if log_context:
+            data = build_stack_data(self.llm_handler)
+            log_context.stacks.append({"component": "llm_handler", "data": data})
+        return resp

application/agents/llm_handler.py

@@ -0,0 +1,254 @@
+import json
+from abc import ABC, abstractmethod
+
+from application.logging import build_stack_data
+
+
+class LLMHandler(ABC):
+    def __init__(self):
+        self.llm_calls = []
+        self.tool_calls = []
+
+    @abstractmethod
+    def handle_response(self, agent, resp, tools_dict, messages, **kwargs):
+        pass
+
+
+class OpenAILLMHandler(LLMHandler):
+    def handle_response(self, agent, resp, tools_dict, messages, stream: bool = True):
+        if not stream:
+            while hasattr(resp, "finish_reason") and resp.finish_reason == "tool_calls":
+                message = json.loads(resp.model_dump_json())["message"]
+                keys_to_remove = {"audio", "function_call", "refusal"}
+                filtered_data = {
+                    k: v for k, v in message.items() if k not in keys_to_remove
+                }
+                messages.append(filtered_data)
+
+                tool_calls = resp.message.tool_calls
+                for call in tool_calls:
+                    try:
+                        self.tool_calls.append(call)
+                        tool_response, call_id = agent._execute_tool_action(
+                            tools_dict, call
+                        )
+                        function_call_dict = {
+                            "function_call": {
+                                "name": call.function.name,
+                                "args": call.function.arguments,
+                                "call_id": call_id,
+                            }
+                        }
+                        function_response_dict = {
+                            "function_response": {
+                                "name": call.function.name,
+                                "response": {"result": tool_response},
+                                "call_id": call_id,
+                            }
+                        }
+
+                        messages.append(
+                            {"role": "assistant", "content": [function_call_dict]}
+                        )
+                        messages.append(
+                            {"role": "tool", "content": [function_response_dict]}
+                        )
+
+                    except Exception as e:
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "content": f"Error executing tool: {str(e)}",
+                                "tool_call_id": call_id,
+                            }
+                        )
+                resp = agent.llm.gen_stream(
+                    model=agent.gpt_model, messages=messages, tools=agent.tools
+                )
+                self.llm_calls.append(build_stack_data(agent.llm))
+            return resp
+
+        else:
+            while True:
+                tool_calls = {}
+                for chunk in resp:
+                    if isinstance(chunk, str) and len(chunk) > 0:
+                        return
+                    elif hasattr(chunk, "delta"): 
+                        chunk_delta = chunk.delta
+
+                        if (
+                            hasattr(chunk_delta, "tool_calls")
+                            and chunk_delta.tool_calls is not None
+                        ):
+                            for tool_call in chunk_delta.tool_calls:
+                                index = tool_call.index
+                                if index not in tool_calls:
+                                    tool_calls[index] = {
+                                        "id": "",
+                                        "function": {"name": "", "arguments": ""},
+                                    }
+
+                                current = tool_calls[index]
+                                if tool_call.id:
+                                    current["id"] = tool_call.id
+                                if tool_call.function.name:
+                                    current["function"][
+                                        "name"
+                                    ] = tool_call.function.name
+                                if tool_call.function.arguments:
+                                    current["function"][
+                                        "arguments"
+                                    ] += tool_call.function.arguments
+                                tool_calls[index] = current
+
+                        if (
+                            hasattr(chunk, "finish_reason")
+                            and chunk.finish_reason == "tool_calls"
+                        ):
+                            for index in sorted(tool_calls.keys()):
+                                call = tool_calls[index]
+                                try:
+                                    self.tool_calls.append(call)
+                                    tool_response, call_id = agent._execute_tool_action(
+                                        tools_dict, call
+                                    )
+                                    if isinstance(call["function"]["arguments"], str):
+                                        call["function"]["arguments"] = json.loads(call["function"]["arguments"])
+
+                                    function_call_dict = {
+                                        "function_call": {
+                                            "name": call["function"]["name"],
+                                            "args": call["function"]["arguments"],
+                                            "call_id": call["id"],
+                                        }
+                                    }
+                                    function_response_dict = {
+                                        "function_response": {
+                                            "name": call["function"]["name"],
+                                            "response": {"result": tool_response},
+                                            "call_id": call["id"],
+                                        }
+                                    }
+
+                                    messages.append(
+                                        {
+                                            "role": "assistant",
+                                            "content": [function_call_dict],
+                                        }
+                                    )
+                                    messages.append(
+                                        {
+                                            "role": "tool",
+                                            "content": [function_response_dict],
+                                        }
+                                    )
+
+                                except Exception as e:
+                                    messages.append(
+                                        {
+                                            "role": "assistant",
+                                            "content": f"Error executing tool: {str(e)}",
+                                        }
+                                    )
+                            tool_calls = {}
+
+                        if (
+                            hasattr(chunk, "finish_reason")
+                            and chunk.finish_reason == "stop"
+                        ):
+                            return
+                    elif isinstance(chunk, str) and len(chunk) == 0:
+                            continue
+
+                resp = agent.llm.gen_stream(
+                    model=agent.gpt_model, messages=messages, tools=agent.tools
+                )
+                self.llm_calls.append(build_stack_data(agent.llm))
+
+
+class GoogleLLMHandler(LLMHandler):
+    def handle_response(self, agent, resp, tools_dict, messages, stream: bool = True):
+        from google.genai import types
+
+        while True:
+            if not stream:
+                response = agent.llm.gen(
+                    model=agent.gpt_model, messages=messages, tools=agent.tools
+                )
+                self.llm_calls.append(build_stack_data(agent.llm))
+                if response.candidates and response.candidates[0].content.parts:
+                    tool_call_found = False
+                    for part in response.candidates[0].content.parts:
+                        if part.function_call:
+                            tool_call_found = True
+                            self.tool_calls.append(part.function_call)
+                            tool_response, call_id = agent._execute_tool_action(
+                                tools_dict, part.function_call
+                            )
+                            function_response_part = types.Part.from_function_response(
+                                name=part.function_call.name,
+                                response={"result": tool_response},
+                            )
+
+                            messages.append(
+                                {"role": "model", "content": [part.to_json_dict()]}
+                            )
+                            messages.append(
+                                {
+                                    "role": "tool",
+                                    "content": [function_response_part.to_json_dict()],
+                                }
+                            )
+
+                    if (
+                        not tool_call_found
+                        and response.candidates[0].content.parts
+                        and response.candidates[0].content.parts[0].text
+                    ):
+                        return response.candidates[0].content.parts[0].text
+                    elif not tool_call_found:
+                        return response.candidates[0].content.parts
+
+                else:
+                    return response
+
+            else:
+                response = agent.llm.gen_stream(
+                    model=agent.gpt_model, messages=messages, tools=agent.tools
+                )
+                self.llm_calls.append(build_stack_data(agent.llm))
+
+                tool_call_found = False
+                for result in response:
+                    if hasattr(result, "function_call"):
+                        tool_call_found = True
+                        self.tool_calls.append(result.function_call)
+                        tool_response, call_id = agent._execute_tool_action(
+                            tools_dict, result.function_call
+                        )
+                        function_response_part = types.Part.from_function_response(
+                            name=result.function_call.name,
+                            response={"result": tool_response},
+                        )
+
+                        messages.append(
+                            {"role": "model", "content": [result.to_json_dict()]}
+                        )
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "content": [function_response_part.to_json_dict()],
+                            }
+                        )
+
+                if not tool_call_found:
+                    return response
+
+
+def get_llm_handler(llm_type):
+    handlers = {
+        "openai": OpenAILLMHandler(),
+        "google": GoogleLLMHandler(),
+    }
+    return handlers.get(llm_type, OpenAILLMHandler())

application/agents/tools/api_tool.py

@@ -0,0 +1,100 @@
+import json
+
+import requests
+from application.agents.tools.base import Tool
+
+
+class APITool(Tool):
+    """
+    API Tool
+    A flexible tool for performing various API actions (e.g., sending messages, retrieving data) via custom user-specified APIs
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self.url = config.get("url", "")
+        self.method = config.get("method", "GET")
+        self.headers = config.get("headers", {"Content-Type": "application/json"})
+        self.query_params = config.get("query_params", {})
+
+    def execute_action(self, action_name, **kwargs):
+        return self._make_api_call(
+            self.url, self.method, self.headers, self.query_params, kwargs
+        )
+
+    def _make_api_call(self, url, method, headers, query_params, body):
+        sanitized_headers = {}
+        for key, value in headers.items():
+            if isinstance(value, str):
+                sanitized_value = value.encode('latin-1', errors='ignore').decode('latin-1')
+                sanitized_headers[key] = sanitized_value
+            else:
+                sanitized_headers[key] = value
+
+        if query_params:
+            url = f"{url}?{requests.compat.urlencode(query_params)}"
+        if isinstance(body, dict):
+            body = json.dumps(body)
+        response = None
+        try:
+            print(f"Making API call: {method} {url} with body: {body}")
+            if body == "{}":
+                body = None
+
+            proxy_id = self.config.get("proxy_id", None)
+            request_kwargs = {
+                'method': method,
+                'url': url,
+                'headers': sanitized_headers,
+                'data': body
+            }
+            try:
+                if proxy_id:
+                    from application.agents.tools.proxy_handler import apply_proxy_to_request
+                    response = apply_proxy_to_request(
+                        requests.request,
+                        proxy_id=proxy_id,
+                        **request_kwargs
+                    )
+                else:
+                    response = requests.request(**request_kwargs)
+            except ImportError:
+                response = requests.request(**request_kwargs)
+            response.raise_for_status()
+            content_type = response.headers.get(
+                "Content-Type", "application/json"
+            ).lower()
+            if "application/json" in content_type:
+                try:
+                    data = response.json()
+                except json.JSONDecodeError as e:
+                    print(f"Error decoding JSON: {e}.  Raw response: {response.text}")
+                    return {
+                        "status_code": response.status_code,
+                        "message": f"API call returned invalid JSON.  Error: {e}",
+                        "data": response.text,
+                    }
+            elif "text/" in content_type or "application/xml" in content_type:
+                data = response.text
+            elif not response.content:
+                data = None
+            else:
+                print(f"Unsupported content type: {content_type}")
+                data = response.content
+
+            return {
+                "status_code": response.status_code,
+                "data": data,
+                "message": "API call successful.",
+            }
+        except requests.exceptions.RequestException as e:
+            return {
+                "status_code": response.status_code if response else None,
+                "message": f"API call failed: {str(e)}",
+            }
+
+    def get_actions_metadata(self):
+        return []
+
+    def get_config_requirements(self):
+        return {}

application/agents/tools/base.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+
+class Tool(ABC):
+    @abstractmethod
+    def execute_action(self, action_name: str, **kwargs):
+        pass
+
+    @abstractmethod
+    def get_actions_metadata(self):
+        """
+        Returns a list of JSON objects describing the actions supported by the tool.
+        """
+        pass
+
+    @abstractmethod
+    def get_config_requirements(self):
+        """
+        Returns a dictionary describing the configuration requirements for the tool.
+        """
+        pass

application/agents/tools/brave.py

@@ -0,0 +1,217 @@
+import requests
+from application.agents.tools.base import Tool
+
+
+class BraveSearchTool(Tool):
+    """
+    Brave Search
+    A tool for performing web and image searches using the Brave Search API.
+    Requires an API key for authentication.
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self.token = config.get("token", "")
+        self.base_url = "https://api.search.brave.com/res/v1"
+
+    def execute_action(self, action_name, **kwargs):
+        actions = {
+            "brave_web_search": self._web_search,
+            "brave_image_search": self._image_search,
+        }
+
+        if action_name in actions:
+            return actions[action_name](**kwargs)
+        else:
+            raise ValueError(f"Unknown action: {action_name}")
+
+    def _web_search(self, query, country="ALL", search_lang="en", count=10, 
+                   offset=0, safesearch="off", freshness=None, 
+                   result_filter=None, extra_snippets=False, summary=False):
+        """
+        Performs a web search using the Brave Search API.
+        """
+        print(f"Performing Brave web search for: {query}")
+        
+        url = f"{self.base_url}/web/search"
+        
+        # Build query parameters
+        params = {
+            "q": query,
+            "country": country,
+            "search_lang": search_lang,
+            "count": min(count, 20),
+            "offset": min(offset, 9),
+            "safesearch": safesearch
+        }
+        
+        # Add optional parameters only if they have values
+        if freshness:
+            params["freshness"] = freshness
+        if result_filter:
+            params["result_filter"] = result_filter
+        if extra_snippets:
+            params["extra_snippets"] = 1
+        if summary:
+            params["summary"] = 1
+        
+        # Set up headers
+        headers = {
+            "Accept": "application/json",
+            "Accept-Encoding": "gzip",
+            "X-Subscription-Token": self.token
+        }
+        
+        # Make the request
+        response = requests.get(url, params=params, headers=headers)
+        
+        if response.status_code == 200:
+            return {
+                "status_code": response.status_code,
+                "results": response.json(),
+                "message": "Search completed successfully."
+            }
+        else:
+            return {
+                "status_code": response.status_code,
+                "message": f"Search failed with status code: {response.status_code}."
+            }
+    
+    def _image_search(self, query, country="ALL", search_lang="en", count=5, 
+                     safesearch="off", spellcheck=False):
+        """
+        Performs an image search using the Brave Search API.
+        """
+        print(f"Performing Brave image search for: {query}")
+        
+        url = f"{self.base_url}/images/search"
+        
+        # Build query parameters
+        params = {
+            "q": query,
+            "country": country,
+            "search_lang": search_lang,
+            "count": min(count, 100),  # API max is 100
+            "safesearch": safesearch,
+            "spellcheck": 1 if spellcheck else 0
+        }
+        
+        # Set up headers
+        headers = {
+            "Accept": "application/json",
+            "Accept-Encoding": "gzip",
+            "X-Subscription-Token": self.token
+        }
+        
+        # Make the request
+        response = requests.get(url, params=params, headers=headers)
+        
+        if response.status_code == 200:
+            return {
+                "status_code": response.status_code,
+                "results": response.json(),
+                "message": "Image search completed successfully."
+            }
+        else:
+            return {
+                "status_code": response.status_code,
+                "message": f"Image search failed with status code: {response.status_code}."
+            }
+
+    def get_actions_metadata(self):
+        return [
+            {
+                "name": "brave_web_search",
+                "description": "Perform a web search using Brave Search",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query (max 400 characters, 50 words)",
+                        },
+                        # "country": {
+                        #     "type": "string",
+                        #     "description": "The 2-character country code (default: US)",
+                        # },
+                        "search_lang": {
+                            "type": "string",
+                            "description": "The search language preference (default: en)",
+                        },
+                        # "count": {
+                        #     "type": "integer",
+                        #     "description": "Number of results to return (max 20, default: 10)",
+                        # },
+                        # "offset": {
+                        #     "type": "integer",
+                        #     "description": "Pagination offset (max 9, default: 0)",
+                        # },
+                        # "safesearch": {
+                        #     "type": "string",
+                        #     "description": "Filter level for adult content (off, moderate, strict)",
+                        # },
+                        "freshness": {
+                            "type": "string",
+                            "description": "Time filter for results (pd: last 24h, pw: last week, pm: last month, py: last year)",
+                        },
+                        # "result_filter": {
+                        #     "type": "string",
+                        #     "description": "Comma-delimited list of result types to include",
+                        # },
+                        # "extra_snippets": {
+                        #     "type": "boolean",
+                        #     "description": "Get additional excerpts from result pages",
+                        # },
+                        # "summary": {
+                        #     "type": "boolean",
+                        #     "description": "Enable summary generation in search results",
+                        # }
+                    },
+                    "required": ["query"],
+                    "additionalProperties": False,
+                },
+            },
+            {
+                "name": "brave_image_search",
+                "description": "Perform an image search using Brave Search",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query (max 400 characters, 50 words)",
+                        },
+                        # "country": {
+                        #     "type": "string",
+                        #     "description": "The 2-character country code (default: US)",
+                        # },
+                        # "search_lang": {
+                        #     "type": "string",
+                        #     "description": "The search language preference (default: en)",
+                        # },
+                        "count": {
+                            "type": "integer",
+                            "description": "Number of results to return (max 100, default: 5)",
+                        },
+                        # "safesearch": {
+                        #     "type": "string",
+                        #     "description": "Filter level for adult content (off, strict). Default: strict",
+                        # },
+                        # "spellcheck": {
+                        #     "type": "boolean",
+                        #     "description": "Whether to spellcheck provided query (default: true)",
+                        # }
+                    },
+                    "required": ["query"],
+                    "additionalProperties": False,
+                },
+            }
+        ]
+
+    def get_config_requirements(self):
+        return {
+            "token": {
+                "type": "string", 
+                "description": "Brave Search API key for authentication"
+            },
+        }

application/agents/tools/cryptoprice.py

@@ -0,0 +1,76 @@
+import requests
+from application.agents.tools.base import Tool
+
+
+class CryptoPriceTool(Tool):
+    """
+    CryptoPrice
+    A tool for retrieving cryptocurrency prices using the CryptoCompare public API
+    """
+
+    def __init__(self, config):
+        self.config = config
+
+    def execute_action(self, action_name, **kwargs):
+        actions = {"cryptoprice_get": self._get_price}
+
+        if action_name in actions:
+            return actions[action_name](**kwargs)
+        else:
+            raise ValueError(f"Unknown action: {action_name}")
+
+    def _get_price(self, symbol, currency):
+        """
+        Fetches the current price of a given cryptocurrency symbol in the specified currency.
+        Example:
+            symbol = "BTC"
+            currency = "USD"
+            returns price in USD.
+        """
+        url = f"https://min-api.cryptocompare.com/data/price?fsym={symbol.upper()}&tsyms={currency.upper()}"
+        response = requests.get(url)
+        if response.status_code == 200:
+            data = response.json()
+            if currency.upper() in data:
+                return {
+                    "status_code": response.status_code,
+                    "price": data[currency.upper()],
+                    "message": f"Price of {symbol.upper()} in {currency.upper()} retrieved successfully.",
+                }
+            else:
+                return {
+                    "status_code": response.status_code,
+                    "message": f"Couldn't find price for {symbol.upper()} in {currency.upper()}.",
+                }
+        else:
+            return {
+                "status_code": response.status_code,
+                "message": "Failed to retrieve price.",
+            }
+
+    def get_actions_metadata(self):
+        return [
+            {
+                "name": "cryptoprice_get",
+                "description": "Retrieve the price of a specified cryptocurrency in a given currency",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "symbol": {
+                            "type": "string",
+                            "description": "The cryptocurrency symbol (e.g. BTC)",
+                        },
+                        "currency": {
+                            "type": "string",
+                            "description": "The currency in which you want the price (e.g. USD)",
+                        },
+                    },
+                    "required": ["symbol", "currency"],
+                    "additionalProperties": False,
+                },
+            }
+        ]
+
+    def get_config_requirements(self):
+        # No specific configuration needed for this tool as it just queries a public endpoint
+        return {}

application/agents/tools/ntfy.py

@@ -0,0 +1,127 @@
+import requests
+from application.agents.tools.base import Tool
+
+class NtfyTool(Tool):
+    """
+    Ntfy Tool
+    A tool for sending notifications to ntfy topics on a specified server.
+    """
+
+    def __init__(self, config):
+        """
+        Initialize the NtfyTool with configuration.
+
+        Args:
+            config (dict): Configuration dictionary containing the access token.
+        """
+        self.config = config
+        self.token = config.get("token", "")
+
+    def execute_action(self, action_name, **kwargs):
+        """
+        Execute the specified action with given parameters.
+
+        Args:
+            action_name (str): Name of the action to execute.
+            **kwargs: Parameters for the action, including server_url.
+
+        Returns:
+            dict: Result of the action with status code and message.
+
+        Raises:
+            ValueError: If the action name is unknown.
+        """
+        actions = {
+            "ntfy_send_message": self._send_message,
+        }
+        if action_name in actions:
+            return actions[action_name](**kwargs)
+        else:
+            raise ValueError(f"Unknown action: {action_name}")
+
+    def _send_message(self, server_url, message, topic, title=None, priority=None):
+        """
+        Send a message to an ntfy topic on the specified server.
+
+        Args:
+            server_url (str): Base URL of the ntfy server (e.g., https://ntfy.sh).
+            message (str): The message text to send.
+            topic (str): The topic to send the message to.
+            title (str, optional): Title of the notification.
+            priority (int, optional): Priority of the notification (1-5).
+
+        Returns:
+            dict: Response with status code and a confirmation message.
+
+        Raises:
+            ValueError: If priority is not an integer between 1 and 5.
+        """
+        url = f"{server_url.rstrip('/')}/{topic}"
+        headers = {}
+        if title:
+            headers["X-Title"] = title
+        if priority:
+            try:
+                priority = int(priority)
+            except (ValueError, TypeError):
+                raise ValueError("Priority must be convertible to an integer")
+            if priority < 1 or priority > 5:
+                raise ValueError("Priority must be an integer between 1 and 5")
+            headers["X-Priority"] = str(priority)
+        if self.token:
+            headers["Authorization"] = f"Basic {self.token}"
+        data = message.encode("utf-8")
+        response = requests.post(url, headers=headers, data=data)
+        return {"status_code": response.status_code, "message": "Message sent"}
+
+    def get_actions_metadata(self):
+        """
+        Provide metadata about available actions.
+
+        Returns:
+            list: List of dictionaries describing each action.
+        """
+        return [
+            {
+                "name": "ntfy_send_message",
+                "description": "Send a notification to an ntfy topic",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "server_url": {
+                            "type": "string",
+                            "description": "Base URL of the ntfy server",
+                        },
+                        "message": {
+                            "type": "string",
+                            "description": "Text to send in the notification",
+                        },
+                        "topic": {
+                            "type": "string",
+                            "description": "Topic to send the notification to",
+                        },
+                        "title": {
+                            "type": "string",
+                            "description": "Title of the notification (optional)",
+                        },
+                        "priority": {
+                            "type": "integer",
+                            "description": "Priority of the notification (1-5, optional)",
+                        },
+                    },
+                    "required": ["server_url", "message", "topic"],
+                    "additionalProperties": False,
+                },
+            },
+        ]
+
+    def get_config_requirements(self):
+        """
+        Specify the configuration requirements.
+
+        Returns:
+            dict: Dictionary describing required config parameters.
+        """
+        return {
+            "token": {"type": "string", "description": "Access token for authentication"},
+        }

application/agents/tools/postgres.py

@@ -0,0 +1,163 @@
+import psycopg2
+from application.agents.tools.base import Tool
+
+class PostgresTool(Tool):
+    """
+    PostgreSQL Database Tool
+    A tool for connecting to a PostgreSQL database using a connection string,
+    executing SQL queries, and retrieving schema information.
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self.connection_string = config.get("token", "")
+
+    def execute_action(self, action_name, **kwargs):
+        actions = {
+            "postgres_execute_sql": self._execute_sql,
+            "postgres_get_schema": self._get_schema,
+        }
+
+        if action_name in actions:
+            return actions[action_name](**kwargs)
+        else:
+            raise ValueError(f"Unknown action: {action_name}")
+
+    def _execute_sql(self, sql_query):
+        """
+        Executes an SQL query against the PostgreSQL database using a connection string.
+        """
+        conn = None  # Initialize conn to None for error handling
+        try:
+            conn = psycopg2.connect(self.connection_string)
+            cur = conn.cursor()
+            cur.execute(sql_query)
+            conn.commit()
+
+            if sql_query.strip().lower().startswith("select"):
+                column_names = [desc[0] for desc in cur.description] if cur.description else []
+                results = []
+                rows = cur.fetchall()
+                for row in rows:
+                    results.append(dict(zip(column_names, row)))
+                response_data = {"data": results, "column_names": column_names}
+            else:
+                row_count = cur.rowcount
+                response_data = {"message": f"Query executed successfully, {row_count} rows affected."}
+
+            cur.close()
+            return {
+                "status_code": 200,
+                "message": "SQL query executed successfully.",
+                "response_data": response_data,
+            }
+
+        except psycopg2.Error as e:
+            error_message = f"Database error: {e}"
+            print(f"Database error: {e}")
+            return {
+                "status_code": 500,
+                "message": "Failed to execute SQL query.",
+                "error": error_message,
+            }
+        finally:
+            if conn:  # Ensure connection is closed even if errors occur
+                conn.close()
+
+    def _get_schema(self, db_name):
+        """
+        Retrieves the schema of the PostgreSQL database using a connection string.
+        """
+        conn = None # Initialize conn to None for error handling
+        try:
+            conn = psycopg2.connect(self.connection_string)
+            cur = conn.cursor()
+
+            cur.execute("""
+                SELECT
+                    table_name,
+                    column_name,
+                    data_type,
+                    column_default,
+                    is_nullable
+                FROM
+                    information_schema.columns
+                WHERE
+                    table_schema = 'public'
+                ORDER BY
+                    table_name,
+                    ordinal_position;
+            """)
+
+            schema_data = {}
+            for row in cur.fetchall():
+                table_name, column_name, data_type, column_default, is_nullable = row
+                if table_name not in schema_data:
+                    schema_data[table_name] = []
+                schema_data[table_name].append({
+                    "column_name": column_name,
+                    "data_type": data_type,
+                    "column_default": column_default,
+                    "is_nullable": is_nullable
+                })
+
+            cur.close()
+            return {
+                "status_code": 200,
+                "message": "Database schema retrieved successfully.",
+                "schema": schema_data,
+            }
+
+        except psycopg2.Error as e:
+            error_message = f"Database error: {e}"
+            print(f"Database error: {e}")
+            return {
+                "status_code": 500,
+                "message": "Failed to retrieve database schema.",
+                "error": error_message,
+            }
+        finally:
+            if conn: # Ensure connection is closed even if errors occur
+                conn.close()
+
+    def get_actions_metadata(self):
+        return [
+            {
+                "name": "postgres_execute_sql",
+                "description": "Execute an SQL query against the PostgreSQL database and return the results. Use this tool to interact with the database, e.g., retrieve specific data or perform updates. Only SELECT queries will return data, other queries will return execution status.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "sql_query": {
+                            "type": "string",
+                            "description": "The SQL query to execute.",
+                        },
+                    },
+                    "required": ["sql_query"],
+                    "additionalProperties": False,
+                },
+            },
+            {
+                "name": "postgres_get_schema",
+                "description": "Retrieve the schema of the PostgreSQL database, including tables and their columns. Use this to understand the database structure before executing queries. db_name is 'default' if not provided.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "db_name": {
+                            "type": "string",
+                            "description": "The name of the database to retrieve the schema for.",
+                        },
+                    },
+                    "required": ["db_name"],
+                    "additionalProperties": False,
+                },
+            },
+        ]
+
+    def get_config_requirements(self):
+        return {
+            "token": {
+                "type": "string",
+                "description": "PostgreSQL database connection string (e.g., 'postgresql://user:password@host:port/dbname')",
+            },
+        }

application/agents/tools/proxy_handler.py

@@ -0,0 +1,63 @@
+import logging
+import requests
+from typing import Dict, Optional
+from bson.objectid import ObjectId
+
+from application.core.mongo_db import MongoDB
+
+logger = logging.getLogger(__name__)
+
+# Get MongoDB connection
+mongo = MongoDB.get_client()
+db = mongo["docsgpt"]
+proxies_collection = db["proxies"]
+
+def get_proxy_config(proxy_id: str) -> Optional[Dict[str, str]]:
+    """
+    Retrieve proxy configuration from the database.
+    
+    Args:
+        proxy_id: The ID of the proxy configuration
+        
+    Returns:
+        A dictionary with proxy configuration or None if not found
+    """
+    if not proxy_id or proxy_id == "none":
+        return None
+        
+    try:
+        if ObjectId.is_valid(proxy_id):
+            proxy_config = proxies_collection.find_one({"_id": ObjectId(proxy_id)})
+            if proxy_config and "connection" in proxy_config:
+                connection_str = proxy_config["connection"].strip()
+                if connection_str:
+                    # Format proxy for requests library
+                    return {
+                        "http": connection_str,
+                        "https": connection_str
+                    }
+        return None
+    except Exception as e:
+        logger.error(f"Error retrieving proxy configuration: {e}")
+        return None
+
+def apply_proxy_to_request(request_func, proxy_id=None, **kwargs):
+    """
+    Apply proxy configuration to a requests function if available.
+    This is a minimal wrapper that doesn't change the function signature.
+    
+    Args:
+        request_func: The requests function to call (e.g., requests.get, requests.post)
+        proxy_id: Optional proxy ID to use
+        **kwargs: Arguments to pass to the request function
+    
+    Returns:
+        The response from the request
+    """
+    if proxy_id:
+        proxy_config = get_proxy_config(proxy_id)
+        if proxy_config:
+            kwargs['proxies'] = proxy_config
+            logger.info(f"Using proxy for request")
+    
+    return request_func(**kwargs)

application/agents/tools/telegram.py

@@ -0,0 +1,86 @@
+import requests
+from application.agents.tools.base import Tool
+
+
+class TelegramTool(Tool):
+    """
+    Telegram Bot
+    A flexible Telegram tool for performing various actions (e.g., sending messages, images).
+    Requires a bot token and chat ID for configuration
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self.token = config.get("token", "")
+
+    def execute_action(self, action_name, **kwargs):
+        actions = {
+            "telegram_send_message": self._send_message,
+            "telegram_send_image": self._send_image,
+        }
+
+        if action_name in actions:
+            return actions[action_name](**kwargs)
+        else:
+            raise ValueError(f"Unknown action: {action_name}")
+
+    def _send_message(self, text, chat_id):
+        print(f"Sending message: {text}")
+        url = f"https://api.telegram.org/bot{self.token}/sendMessage"
+        payload = {"chat_id": chat_id, "text": text}
+        response = requests.post(url, data=payload)
+        return {"status_code": response.status_code, "message": "Message sent"}
+
+    def _send_image(self, image_url, chat_id):
+        print(f"Sending image: {image_url}")
+        url = f"https://api.telegram.org/bot{self.token}/sendPhoto"
+        payload = {"chat_id": chat_id, "photo": image_url}
+        response = requests.post(url, data=payload)
+        return {"status_code": response.status_code, "message": "Image sent"}
+
+    def get_actions_metadata(self):
+        return [
+            {
+                "name": "telegram_send_message",
+                "description": "Send a notification to Telegram chat",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "text": {
+                            "type": "string",
+                            "description": "Text to send in the notification",
+                        },
+                        "chat_id": {
+                            "type": "string",
+                            "description": "Chat ID to send the notification to",
+                        },
+                    },
+                    "required": ["text"],
+                    "additionalProperties": False,
+                },
+            },
+            {
+                "name": "telegram_send_image",
+                "description": "Send an image to the Telegram chat",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "image_url": {
+                            "type": "string",
+                            "description": "URL of the image to send",
+                        },
+                        "chat_id": {
+                            "type": "string",
+                            "description": "Chat ID to send the image to",
+                        },
+                    },
+                    "required": ["image_url"],
+                    "additionalProperties": False,
+                },
+            },
+        ]
+
+    def get_config_requirements(self):
+        return {
+            "token": {"type": "string", "description": "Bot token for authentication"},
+        }

application/agents/tools/tool_action_parser.py

@@ -0,0 +1,42 @@
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ToolActionParser:
+    def __init__(self, llm_type):
+        self.llm_type = llm_type
+        self.parsers = {
+            "OpenAILLM": self._parse_openai_llm,
+            "GoogleLLM": self._parse_google_llm,
+        }
+
+    def parse_args(self, call):
+        parser = self.parsers.get(self.llm_type, self._parse_openai_llm)
+        return parser(call)
+
+    def _parse_openai_llm(self, call):
+        if isinstance(call, dict):
+            try:
+                call_args = json.loads(call["function"]["arguments"])
+                tool_id = call["function"]["name"].split("_")[-1]
+                action_name = call["function"]["name"].rsplit("_", 1)[0]
+            except (KeyError, TypeError) as e:
+                logger.error(f"Error parsing OpenAI LLM call: {e}")
+                return None, None, None
+        else:
+            try:
+                call_args = json.loads(call.function.arguments)
+                tool_id = call.function.name.split("_")[-1]
+                action_name = call.function.name.rsplit("_", 1)[0]
+            except (AttributeError, TypeError) as e:
+                logger.error(f"Error parsing OpenAI LLM call: {e}")
+                return None, None, None
+        return tool_id, action_name, call_args
+
+    def _parse_google_llm(self, call):
+        call_args = call.args
+        tool_id = call.name.split("_")[-1]
+        action_name = call.name.rsplit("_", 1)[0]
+        return tool_id, action_name, call_args

application/agents/tools/tool_manager.py

@@ -0,0 +1,42 @@
+import importlib
+import inspect
+import os
+import pkgutil
+
+from application.agents.tools.base import Tool
+
+
+class ToolManager:
+    def __init__(self, config):
+        self.config = config
+        self.tools = {}
+        self.load_tools()
+
+    def load_tools(self):
+        tools_dir = os.path.join(os.path.dirname(__file__))
+        for finder, name, ispkg in pkgutil.iter_modules([tools_dir]):
+            if name == "base" or name.startswith("__"):
+                continue
+            module = importlib.import_module(f"application.agents.tools.{name}")
+            for member_name, obj in inspect.getmembers(module, inspect.isclass):
+                if issubclass(obj, Tool) and obj is not Tool:
+                    tool_config = self.config.get(name, {})
+                    self.tools[name] = obj(tool_config)
+
+    def load_tool(self, tool_name, tool_config):
+        self.config[tool_name] = tool_config
+        module = importlib.import_module(f"application.agents.tools.{tool_name}")
+        for member_name, obj in inspect.getmembers(module, inspect.isclass):
+            if issubclass(obj, Tool) and obj is not Tool:
+                return obj(tool_config)
+
+    def execute_action(self, tool_name, action_name, **kwargs):
+        if tool_name not in self.tools:
+            raise ValueError(f"Tool '{tool_name}' not loaded")
+        return self.tools[tool_name].execute_action(action_name, **kwargs)
+
+    def get_all_actions_metadata(self):
+        metadata = []
+        for tool in self.tools.values():
+            metadata.extend(tool.get_actions_metadata())
+        return metadata

application/api/answer/routes.py

@@ -3,14 +3,14 @@ import datetime
 import json
 import logging
 import os
-import sys
 import traceback
 
 from bson.dbref import DBRef
 from bson.objectid import ObjectId
-from flask import Blueprint, current_app, make_response, request, Response
+from flask import Blueprint, make_response, request, Response
 from flask_restx import fields, Namespace, Resource
 
+from application.agents.agent_creator import AgentCreator
 
 from application.core.mongo_db import MongoDB
 from application.core.settings import settings
@@ -18,7 +18,7 @@ from application.error import bad_request
 from application.extensions import api
 from application.llm.llm_creator import LLMCreator
 from application.retriever.retriever_creator import RetrieverCreator
-from application.utils import check_required_fields
+from application.utils import check_required_fields, limit_chat_history
 
 logger = logging.getLogger(__name__)
 
@@ -37,11 +37,13 @@ api.add_namespace(answer_ns)
 gpt_model = ""
 # to have some kind of default behaviour
 if settings.LLM_NAME == "openai":
-    gpt_model = "gpt-3.5-turbo"
+    gpt_model = "gpt-4o-mini"
 elif settings.LLM_NAME == "anthropic":
     gpt_model = "claude-2"
 elif settings.LLM_NAME == "groq":
     gpt_model = "llama3-8b-8192"
+elif settings.LLM_NAME == "novita":
+    gpt_model = "deepseek/deepseek-r1"
 
 if settings.MODEL_NAME:  # in case there is particular model name configured
     gpt_model = settings.MODEL_NAME
@@ -89,9 +91,6 @@ def get_data_from_api_key(api_key):
     if data is None:
         raise Exception("Invalid API Key, please generate new key", 401)
 
-    if "retriever" not in data:
-        data["retriever"] = None
-
     if "source" in data and isinstance(data["source"], DBRef):
         source_doc = db.dereference(data["source"])
         data["source"] = str(source_doc["_id"])
@@ -118,8 +117,37 @@ def is_azure_configured():
     )
 
 
-def save_conversation(conversation_id, question, response, source_log_docs, llm):
-    if conversation_id is not None and conversation_id != "None":
+def save_conversation(
+    conversation_id,
+    question,
+    response,
+    source_log_docs,
+    tool_calls,
+    llm,
+    decoded_token,
+    index=None,
+    api_key=None,
+):
+    current_time = datetime.datetime.now(datetime.timezone.utc)
+    if conversation_id is not None and index is not None:
+        conversations_collection.update_one(
+            {"_id": ObjectId(conversation_id), f"queries.{index}": {"$exists": True}},
+            {
+                "$set": {
+                    f"queries.{index}.prompt": question,
+                    f"queries.{index}.response": response,
+                    f"queries.{index}.sources": source_log_docs,
+                    f"queries.{index}.tool_calls": tool_calls,
+                    f"queries.{index}.timestamp": current_time,
+                }
+            },
+        )
+        ##remove following queries from the array
+        conversations_collection.update_one(
+            {"_id": ObjectId(conversation_id), f"queries.{index}": {"$exists": True}},
+            {"$push": {"queries": {"$each": [], "$slice": index + 1}}},
+        )
+    elif conversation_id is not None and conversation_id != "None":
         conversations_collection.update_one(
             {"_id": ObjectId(conversation_id)},
             {
@@ -128,6 +156,8 @@ def save_conversation(conversation_id, question, response, source_log_docs, llm)
                         "prompt": question,
                         "response": response,
                         "sources": source_log_docs,
+                        "tool_calls": tool_calls,
+                        "timestamp": current_time,
                     }
                 }
             },
@@ -147,28 +177,31 @@ def save_conversation(conversation_id, question, response, source_log_docs, llm)
                 "role": "user",
                 "content": "Summarise following conversation in no more than 3 words, "
                 "respond ONLY with the summary, use the same language as the "
-                "system \n\nUser: "
-                + question
-                + "\n\n"
-                + "AI: "
-                + response,
+                "system \n\nUser: " + question + "\n\n" + "AI: " + response,
             },
         ]
 
         completion = llm.gen(model=gpt_model, messages=messages_summary, max_tokens=30)
+        conversation_data = {
+            "user": decoded_token.get("sub"),
+            "date": datetime.datetime.utcnow(),
+            "name": completion,
+            "queries": [
+                {
+                    "prompt": question,
+                    "response": response,
+                    "sources": source_log_docs,
+                    "tool_calls": tool_calls,
+                    "timestamp": current_time,
+                }
+            ],
+        }
+        if api_key:
+            api_key_doc = api_key_collection.find_one({"key": api_key})
+            if api_key_doc:
+                conversation_data["api_key"] = api_key_doc["key"]
         conversation_id = conversations_collection.insert_one(
-            {
-                "user": "local",
-                "date": datetime.datetime.utcnow(),
-                "name": completion,
-                "queries": [
-                    {
-                        "prompt": question,
-                        "response": response,
-                        "sources": source_log_docs,
-                    }
-                ],
-            }
+            conversation_data
         ).inserted_id
     return conversation_id
 
@@ -186,49 +219,82 @@ def get_prompt(prompt_id):
 
 
 def complete_stream(
-    question, retriever, conversation_id, user_api_key, isNoneDoc=False
+    question,
+    agent,
+    retriever,
+    conversation_id,
+    user_api_key,
+    decoded_token,
+    isNoneDoc=False,
+    index=None,
+    should_save_conversation=True,
 ):
-
     try:
         response_full = ""
         source_log_docs = []
-        answer = retriever.gen()
-        sources = retriever.search()
-        for source in sources:
-            if "text" in source:
-                source["text"] = source["text"][:100].strip() + "..."
-        if len(sources) > 0:
-            data = json.dumps({"type": "source", "source": sources})
-            yield f"data: {data}\n\n"
+        tool_calls = []
+
+        answer = agent.gen(query=question, retriever=retriever)
+
         for line in answer:
             if "answer" in line:
                 response_full += str(line["answer"])
-                data = json.dumps(line)
+                data = json.dumps({"type": "answer", "answer": line["answer"]})
+                yield f"data: {data}\n\n"
+            elif "sources" in line:
+                truncated_sources = []
+                source_log_docs = line["sources"]
+                for source in line["sources"]:
+                    truncated_source = source.copy()
+                    if "text" in truncated_source:
+                        truncated_source["text"] = (
+                            truncated_source["text"][:100].strip() + "..."
+                        )
+                    truncated_sources.append(truncated_source)
+                if len(truncated_sources) > 0:
+                    data = json.dumps({"type": "source", "source": truncated_sources})
+                    yield f"data: {data}\n\n"
+            elif "tool_calls" in line:
+                tool_calls = line["tool_calls"]
+                data = json.dumps({"type": "tool_calls", "tool_calls": tool_calls})
                 yield f"data: {data}\n\n"
-            elif "source" in line:
-                source_log_docs.append(line["source"])
 
         if isNoneDoc:
             for doc in source_log_docs:
                 doc["source"] = "None"
 
         llm = LLMCreator.create_llm(
-            settings.LLM_NAME, api_key=settings.API_KEY, user_api_key=user_api_key
+            settings.LLM_NAME,
+            api_key=settings.API_KEY,
+            user_api_key=user_api_key,
+            decoded_token=decoded_token,
         )
-        if user_api_key is None:
+
+        if should_save_conversation:
             conversation_id = save_conversation(
-                conversation_id, question, response_full, source_log_docs, llm
+                conversation_id,
+                question,
+                response_full,
+                source_log_docs,
+                tool_calls,
+                llm,
+                decoded_token,
+                index,
+                api_key=user_api_key,
             )
-            # send data.type = "end" to indicate that the stream has ended as json
-            data = json.dumps({"type": "id", "id": str(conversation_id)})
-            yield f"data: {data}\n\n"
+        else:
+            conversation_id = None
+
+        # send data.type = "end" to indicate that the stream has ended as json
+        data = json.dumps({"type": "id", "id": str(conversation_id)})
+        yield f"data: {data}\n\n"
 
         retriever_params = retriever.get_params()
         user_logs_collection.insert_one(
             {
                 "action": "stream_answer",
                 "level": "info",
-                "user": "local",
+                "user": decoded_token.get("sub"),
                 "api_key": user_api_key,
                 "question": question,
                 "response": response_full,
@@ -240,13 +306,12 @@ def complete_stream(
         data = json.dumps({"type": "end"})
         yield f"data: {data}\n\n"
     except Exception as e:
-        print("\033[91merr", str(e), file=sys.stderr)
-        traceback.print_exc()
+        logger.error(f"Error in stream: {str(e)}")
+        logger.error(traceback.format_exc())
         data = json.dumps(
             {
                 "type": "error",
                 "error": "Please try again later. We apologize for any inconvenience.",
-                "error_exception": str(e),
             }
         )
         yield f"data: {data}\n\n"
@@ -270,6 +335,9 @@ class Stream(Resource):
             "prompt_id": fields.String(
                 required=False, default="default", description="Prompt ID"
             ),
+            "proxy_id": fields.String(
+                required=False, description="Proxy ID to use for API calls"
+            ),
             "chunks": fields.Integer(
                 required=False, default=2, description="Number of chunks"
             ),
@@ -282,6 +350,12 @@ class Stream(Resource):
             "isNoneDoc": fields.Boolean(
                 required=False, description="Flag indicating if no document is used"
             ),
+            "index": fields.Integer(
+                required=False, description="The position where query is to be updated"
+            ),
+            "save_conversation": fields.Boolean(
+                required=False, default=True, description="Flag to save conversation"
+            ),
         },
     )
 
@@ -290,19 +364,24 @@ class Stream(Resource):
     def post(self):
         data = request.get_json()
         required_fields = ["question"]
-
+        if "index" in data:
+            required_fields = ["question", "conversation_id"]
         missing_fields = check_required_fields(data, required_fields)
         if missing_fields:
             return missing_fields
 
+        save_conv = data.get("save_conversation", True)
+
         try:
             question = data["question"]
-            history = data.get("history", [])
-            history = json.loads(history)
+            history = limit_chat_history(
+                json.loads(data.get("history", [])), gpt_model=gpt_model
+            )
             conversation_id = data.get("conversation_id")
             prompt_id = data.get("prompt_id", "default")
-            
+            proxy_id = data.get("proxy_id", None)
 
+            index = data.get("index", None)
             chunks = int(data.get("chunks", 2))
             token_limit = data.get("token_limit", settings.DEFAULT_MAX_HISTORY)
             retriever_name = data.get("retriever", "classic")
@@ -311,20 +390,27 @@ class Stream(Resource):
                 data_key = get_data_from_api_key(data["api_key"])
                 chunks = int(data_key.get("chunks", 2))
                 prompt_id = data_key.get("prompt_id", "default")
+                proxy_id = data_key.get("proxy_id", None)
                 source = {"active_docs": data_key.get("source")}
                 retriever_name = data_key.get("retriever", retriever_name)
                 user_api_key = data["api_key"]
+                decoded_token = {"sub": data_key.get("user")}
 
             elif "active_docs" in data:
                 source = {"active_docs": data["active_docs"]}
                 retriever_name = get_retriever(data["active_docs"]) or retriever_name
                 user_api_key = None
+                decoded_token = request.decoded_token
 
             else:
                 source = {}
                 user_api_key = None
+                decoded_token = request.decoded_token
 
-            current_app.logger.info(
+            if not decoded_token:
+                return make_response({"error": "Unauthorized"}, 401)
+
+            logger.info(
                 f"/stream - request_data: {data}, source: {source}",
                 extra={"data": json.dumps({"request_data": data, "source": source})},
             )
@@ -332,9 +418,22 @@ class Stream(Resource):
             prompt = get_prompt(prompt_id)
             if "isNoneDoc" in data and data["isNoneDoc"] is True:
                 chunks = 0
+
+            agent = AgentCreator.create_agent(
+                settings.AGENT_NAME,
+                endpoint="stream",
+                llm_name=settings.LLM_NAME,
+                gpt_model=gpt_model,
+                api_key=settings.API_KEY,
+                user_api_key=user_api_key,
+                prompt=prompt,
+                proxy_id=proxy_id,
+                chat_history=history,
+                decoded_token=decoded_token,
+            )
+
             retriever = RetrieverCreator.create_retriever(
                 retriever_name,
-                question=question,
                 source=source,
                 chat_history=history,
                 prompt=prompt,
@@ -342,39 +441,40 @@ class Stream(Resource):
                 token_limit=token_limit,
                 gpt_model=gpt_model,
                 user_api_key=user_api_key,
+                decoded_token=decoded_token,
             )
 
             return Response(
                 complete_stream(
                     question=question,
+                    agent=agent,
                     retriever=retriever,
                     conversation_id=conversation_id,
                     user_api_key=user_api_key,
+                    decoded_token=decoded_token,
                     isNoneDoc=data.get("isNoneDoc"),
+                    index=index,
+                    should_save_conversation=save_conv,
                 ),
                 mimetype="text/event-stream",
             )
 
         except ValueError:
             message = "Malformed request body"
-            print("\033[91merr", str(message), file=sys.stderr)
+            logger.error(f"/stream - error: {message}")
             return Response(
                 error_stream_generate(message),
                 status=400,
                 mimetype="text/event-stream",
             )
         except Exception as e:
-            current_app.logger.error(
+            logger.error(
                 f"/stream - error: {str(e)} - traceback: {traceback.format_exc()}",
                 extra={"error": str(e), "traceback": traceback.format_exc()},
             )
-            message = e.args[0]
             status_code = 400
-            # Custom exceptions with two arguments, index 1 as status code
-            if len(e.args) >= 2:
-                status_code = e.args[1]
             return Response(
-                error_stream_generate(message),
+                error_stream_generate("Unknown error occurred"),
                 status=status_code,
                 mimetype="text/event-stream",
             )
@@ -402,6 +502,9 @@ class Answer(Resource):
             "prompt_id": fields.String(
                 required=False, default="default", description="Prompt ID"
             ),
+            "proxy_id": fields.String(
+                required=False, description="Proxy ID to use for API calls"
+            ),
             "chunks": fields.Integer(
                 required=False, default=2, description="Number of chunks"
             ),
@@ -421,16 +524,19 @@ class Answer(Resource):
     @api.doc(description="Provide an answer based on the question and retriever")
     def post(self):
         data = request.get_json()
-        required_fields = ["question"]       
+        required_fields = ["question"]
         missing_fields = check_required_fields(data, required_fields)
         if missing_fields:
             return missing_fields
 
         try:
             question = data["question"]
-            history = data.get("history", [])
+            history = limit_chat_history(
+                json.loads(data.get("history", [])), gpt_model=gpt_model
+            )
             conversation_id = data.get("conversation_id")
             prompt_id = data.get("prompt_id", "default")
+            proxy_id = data.get("proxy_id", None)
             chunks = int(data.get("chunks", 2))
             token_limit = data.get("token_limit", settings.DEFAULT_MAX_HISTORY)
             retriever_name = data.get("retriever", "classic")
@@ -439,27 +545,48 @@ class Answer(Resource):
                 data_key = get_data_from_api_key(data["api_key"])
                 chunks = int(data_key.get("chunks", 2))
                 prompt_id = data_key.get("prompt_id", "default")
+                proxy_id = data_key.get("proxy_id", None)
                 source = {"active_docs": data_key.get("source")}
                 retriever_name = data_key.get("retriever", retriever_name)
                 user_api_key = data["api_key"]
+                decoded_token = {"sub": data_key.get("user")}
+
             elif "active_docs" in data:
                 source = {"active_docs": data["active_docs"]}
                 retriever_name = get_retriever(data["active_docs"]) or retriever_name
                 user_api_key = None
+                decoded_token = request.decoded_token
+
             else:
                 source = {}
                 user_api_key = None
+                decoded_token = request.decoded_token
+
+            if not decoded_token:
+                return make_response({"error": "Unauthorized"}, 401)
 
             prompt = get_prompt(prompt_id)
 
-            current_app.logger.info(
+            logger.info(
                 f"/api/answer - request_data: {data}, source: {source}",
                 extra={"data": json.dumps({"request_data": data, "source": source})},
             )
 
+            agent = AgentCreator.create_agent(
+                settings.AGENT_NAME,
+                endpoint="api/answer",
+                llm_name=settings.LLM_NAME,
+                gpt_model=gpt_model,
+                api_key=settings.API_KEY,
+                user_api_key=user_api_key,
+                prompt=prompt,
+                proxy_id=proxy_id,
+                chat_history=history,
+                decoded_token=decoded_token,
+            )
+
             retriever = RetrieverCreator.create_retriever(
                 retriever_name,
-                question=question,
                 source=source,
                 chat_history=history,
                 prompt=prompt,
@@ -467,36 +594,80 @@ class Answer(Resource):
                 token_limit=token_limit,
                 gpt_model=gpt_model,
                 user_api_key=user_api_key,
+                decoded_token=decoded_token,
             )
 
-            source_log_docs = []
             response_full = ""
-            for line in retriever.gen():
-                if "source" in line:
-                    source_log_docs.append(line["source"])
-                elif "answer" in line:
-                    response_full += line["answer"]
+            source_log_docs = []
+            tool_calls = []
+            stream_ended = False
+
+            for line in complete_stream(
+                question=question,
+                agent=agent,
+                retriever=retriever,
+                conversation_id=conversation_id,
+                user_api_key=user_api_key,
+                decoded_token=decoded_token,
+                isNoneDoc=data.get("isNoneDoc"),
+                index=None,
+                should_save_conversation=False,
+            ):
+                try:
+                    event_data = line.replace("data: ", "").strip()
+                    event = json.loads(event_data)
+
+                    if event["type"] == "answer":
+                        response_full += event["answer"]
+                    elif event["type"] == "source":
+                        source_log_docs = event["source"]
+                    elif event["type"] == "tool_calls":
+                        tool_calls = event["tool_calls"]
+                    elif event["type"] == "error":
+                        logger.error(f"Error from stream: {event['error']}")
+                        return bad_request(500, event["error"])
+                    elif event["type"] == "end":
+                        stream_ended = True
+
+                except (json.JSONDecodeError, KeyError) as e:
+                    logger.warning(f"Error parsing stream event: {e}, line: {line}")
+                    continue
+
+            if not stream_ended:
+                logger.error("Stream ended unexpectedly without an 'end' event.")
+                return bad_request(500, "Stream ended unexpectedly.")
 
             if data.get("isNoneDoc"):
                 for doc in source_log_docs:
                     doc["source"] = "None"
 
             llm = LLMCreator.create_llm(
-                settings.LLM_NAME, api_key=settings.API_KEY, user_api_key=user_api_key
+                settings.LLM_NAME,
+                api_key=settings.API_KEY,
+                user_api_key=user_api_key,
+                decoded_token=decoded_token,
             )
 
             result = {"answer": response_full, "sources": source_log_docs}
             result["conversation_id"] = str(
                 save_conversation(
-                    conversation_id, question, response_full, source_log_docs, llm
+                    conversation_id,
+                    question,
+                    response_full,
+                    source_log_docs,
+                    tool_calls,
+                    llm,
+                    decoded_token,
+                    api_key=user_api_key,
                 )
             )
+
             retriever_params = retriever.get_params()
             user_logs_collection.insert_one(
                 {
                     "action": "api_answer",
                     "level": "info",
-                    "user": "local",
+                    "user": decoded_token.get("sub"),
                     "api_key": user_api_key,
                     "question": question,
                     "response": response_full,
@@ -507,7 +678,7 @@ class Answer(Resource):
             )
 
         except Exception as e:
-            current_app.logger.error(
+            logger.error(
                 f"/api/answer - error: {str(e)} - traceback: {traceback.format_exc()}",
                 extra={"error": str(e), "traceback": traceback.format_exc()},
             )
@@ -565,21 +736,28 @@ class Search(Resource):
                 chunks = int(data_key.get("chunks", 2))
                 source = {"active_docs": data_key.get("source")}
                 user_api_key = data["api_key"]
+                decoded_token = {"sub": data_key.get("user")}
+
             elif "active_docs" in data:
                 source = {"active_docs": data["active_docs"]}
                 user_api_key = None
+                decoded_token = request.decoded_token
+
             else:
                 source = {}
                 user_api_key = None
+                decoded_token = request.decoded_token
 
-            current_app.logger.info(
+            if not decoded_token:
+                return make_response({"error": "Unauthorized"}, 401)
+
+            logger.info(
                 f"/api/answer - request_data: {data}, source: {source}",
                 extra={"data": json.dumps({"request_data": data, "source": source})},
             )
 
             retriever = RetrieverCreator.create_retriever(
                 retriever_name,
-                question=question,
                 source=source,
                 chat_history=[],
                 prompt="default",
@@ -587,16 +765,17 @@ class Search(Resource):
                 token_limit=token_limit,
                 gpt_model=gpt_model,
                 user_api_key=user_api_key,
+                decoded_token=decoded_token,
             )
 
-            docs = retriever.search()
+            docs = retriever.search(question)
             retriever_params = retriever.get_params()
 
             user_logs_collection.insert_one(
                 {
                     "action": "api_search",
                     "level": "info",
-                    "user": "local",
+                    "user": decoded_token.get("sub"),
                     "api_key": user_api_key,
                     "question": question,
                     "sources": docs,
@@ -610,7 +789,7 @@ class Search(Resource):
                     doc["source"] = "None"
 
         except Exception as e:
-            current_app.logger.error(
+            logger.error(
                 f"/api/search - error: {str(e)} - traceback: {traceback.format_exc()}",
                 extra={"error": str(e), "traceback": traceback.format_exc()},
             )

application/app.py

@@ -1,15 +1,24 @@
+import os
 import platform
+import uuid
 
 import dotenv
-from flask import Flask, redirect, request
+from flask import Flask, jsonify, redirect, request
+from jose import jwt
+
+from application.auth import handle_auth
 
-from application.api.answer.routes import answer
-from application.api.internal.routes import internal
-from application.api.user.routes import user
-from application.celery_init import celery
 from application.core.logging_config import setup_logging
-from application.core.settings import settings
-from application.extensions import api
+
+setup_logging()
+
+from application.api.answer.routes import answer  # noqa: E402
+from application.api.internal.routes import internal  # noqa: E402
+from application.api.user.routes import user  # noqa: E402
+from application.celery_init import celery  # noqa: E402
+from application.core.settings import settings  # noqa: E402
+from application.extensions import api  # noqa: E402
+
 
 if platform.system() == "Windows":
     import pathlib
@@ -17,7 +26,6 @@ if platform.system() == "Windows":
     pathlib.PosixPath = pathlib.WindowsPath
 
 dotenv.load_dotenv()
-setup_logging()
 
 app = Flask(__name__)
 app.register_blueprint(user)
@@ -32,6 +40,25 @@ app.config.update(
 celery.config_from_object("application.celeryconfig")
 api.init_app(app)
 
+if settings.AUTH_TYPE in ("simple_jwt", "session_jwt") and not settings.JWT_SECRET_KEY:
+    key_file = ".jwt_secret_key"
+    try:
+        with open(key_file, "r") as f:
+            settings.JWT_SECRET_KEY = f.read().strip()
+    except FileNotFoundError:
+        new_key = os.urandom(32).hex()
+        with open(key_file, "w") as f:
+            f.write(new_key)
+        settings.JWT_SECRET_KEY = new_key
+    except Exception as e:
+        raise RuntimeError(f"Failed to setup JWT_SECRET_KEY: {e}")
+
+SIMPLE_JWT_TOKEN = None
+if settings.AUTH_TYPE == "simple_jwt":
+    payload = {"sub": "local"}
+    SIMPLE_JWT_TOKEN = jwt.encode(payload, settings.JWT_SECRET_KEY, algorithm="HS256")
+    print(f"Generated Simple JWT Token: {SIMPLE_JWT_TOKEN}")
+
 
 @app.route("/")
 def home():
@@ -41,11 +68,47 @@ def home():
         return "Welcome to DocsGPT Backend!"
 
 
+@app.route("/api/config")
+def get_config():
+    response = {
+        "auth_type": settings.AUTH_TYPE,
+        "requires_auth": settings.AUTH_TYPE in ["simple_jwt", "session_jwt"],
+    }
+    return jsonify(response)
+
+
+@app.route("/api/generate_token")
+def generate_token():
+    if settings.AUTH_TYPE == "session_jwt":
+        new_user_id = str(uuid.uuid4())
+        token = jwt.encode(
+            {"sub": new_user_id}, settings.JWT_SECRET_KEY, algorithm="HS256"
+        )
+        return jsonify({"token": token})
+    return jsonify({"error": "Token generation not allowed in current auth mode"}), 400
+
+
+@app.before_request
+def authenticate_request():
+    if request.method == "OPTIONS":
+        return "", 200
+
+    decoded_token = handle_auth(request)
+    if not decoded_token:
+        request.decoded_token = None
+    elif "error" in decoded_token:
+        return jsonify(decoded_token), 401
+    else:
+        request.decoded_token = decoded_token
+
+
 @app.after_request
 def after_request(response):
     response.headers.add("Access-Control-Allow-Origin", "*")
-    response.headers.add("Access-Control-Allow-Headers", "Content-Type,Authorization")
-    response.headers.add("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE,OPTIONS")
+    response.headers.add("Access-Control-Allow-Headers", "Content-Type, Authorization")
+    response.headers.add(
+        "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS"
+    )
     return response
 
 

application/auth.py

@@ -0,0 +1,28 @@
+from jose import jwt
+
+from application.core.settings import settings
+
+
+def handle_auth(request, data={}):
+    if settings.AUTH_TYPE in ["simple_jwt", "session_jwt"]:
+        jwt_token = request.headers.get("Authorization")
+        if not jwt_token:
+            return None
+
+        jwt_token = jwt_token.replace("Bearer ", "")
+
+        try:
+            decoded_token = jwt.decode(
+                jwt_token,
+                settings.JWT_SECRET_KEY,
+                algorithms=["HS256"],
+                options={"verify_exp": False},
+            )
+            return decoded_token
+        except Exception as e:
+            return {
+                "message": f"Authentication error: {str(e)}",
+                "error": "invalid_token",
+            }
+    else:
+        return {"sub": "local"}

application/cache.py

@@ -1,93 +1,117 @@
-import redis
-import time
 import json
 import logging
+import time
 from threading import Lock
+
+import redis
+
 from application.core.settings import settings
 from application.utils import get_hash
 
 logger = logging.getLogger(__name__)
 
 _redis_instance = None
+_redis_creation_failed = False
 _instance_lock = Lock()
 
 def get_redis_instance():
-    global _redis_instance
-    if _redis_instance is None:
+    global _redis_instance, _redis_creation_failed
+    if _redis_instance is None and not _redis_creation_failed:
         with _instance_lock:
-            if _redis_instance is None:
+            if _redis_instance is None and not _redis_creation_failed:
                 try:
-                    _redis_instance = redis.Redis.from_url(settings.CACHE_REDIS_URL, socket_connect_timeout=2)
+                    _redis_instance = redis.Redis.from_url(
+                        settings.CACHE_REDIS_URL, socket_connect_timeout=2
+                    )
+                except ValueError as e:
+                    logger.error(f"Invalid Redis URL: {e}")
+                    _redis_creation_failed = True  # Stop future attempts
+                    _redis_instance = None
                 except redis.ConnectionError as e:
                     logger.error(f"Redis connection error: {e}")
-                    _redis_instance = None
+                    _redis_instance = None  # Keep trying for connection errors
     return _redis_instance
 
-def gen_cache_key(*messages, model="docgpt"):
+
+def gen_cache_key(messages, model="docgpt", tools=None):
     if not all(isinstance(msg, dict) for msg in messages):
         raise ValueError("All messages must be dictionaries.")
-    messages_str = json.dumps(list(messages), sort_keys=True)
-    combined = f"{model}_{messages_str}"
+    messages_str = json.dumps(messages)
+    tools_str = json.dumps(str(tools)) if tools else ""
+    combined = f"{model}_{messages_str}_{tools_str}"
     cache_key = get_hash(combined)
     return cache_key
 
+
 def gen_cache(func):
-    def wrapper(self, model, messages, *args, **kwargs):
+    def wrapper(self, model, messages, stream, tools=None, *args, **kwargs):
+        if tools is not None:
+            return func(self, model, messages, stream, tools, *args, **kwargs)
+        
         try:
-            cache_key = gen_cache_key(*messages)
-            redis_client = get_redis_instance()
-            if redis_client:
-                try:
-                    cached_response = redis_client.get(cache_key)
-                    if cached_response:
-                        return cached_response.decode('utf-8')
-                except redis.ConnectionError as e:
-                    logger.error(f"Redis connection error: {e}")
-
-            result = func(self, model, messages, *args, **kwargs)
-            if redis_client:
-                try:
-                    redis_client.set(cache_key, result, ex=1800)
-                except redis.ConnectionError as e:
-                    logger.error(f"Redis connection error: {e}")
-
-            return result
+            cache_key = gen_cache_key(messages, model, tools)
         except ValueError as e:
-            logger.error(e)
-            return "Error: No user message found in the conversation to generate a cache key."
+            logger.error(f"Cache key generation failed: {e}")
+            return func(self, model, messages, stream, tools, *args, **kwargs)
+
+        redis_client = get_redis_instance()
+        if redis_client:
+            try:
+                cached_response = redis_client.get(cache_key)
+                if cached_response:
+                    return cached_response.decode("utf-8")
+            except Exception as e:
+                logger.error(f"Error getting cached response: {e}")
+
+        result = func(self, model, messages, stream, tools, *args, **kwargs)
+        if redis_client and isinstance(result, str):
+            try:
+                redis_client.set(cache_key, result, ex=1800)
+            except Exception as e:
+                logger.error(f"Error setting cache: {e}")
+
+        return result
+
     return wrapper
 
+
 def stream_cache(func):
-    def wrapper(self, model, messages, stream, *args, **kwargs):
-        cache_key = gen_cache_key(*messages)
-        logger.info(f"Stream cache key: {cache_key}")
+    def wrapper(self, model, messages, stream, tools=None, *args, **kwargs):
+        if tools is not None:
+            yield from func(self, model, messages, stream, tools, *args, **kwargs)
+            return
         
+        try:
+            cache_key = gen_cache_key(messages, model, tools)
+        except ValueError as e:
+            logger.error(f"Cache key generation failed: {e}")
+            yield from func(self, model, messages, stream, tools, *args, **kwargs)
+            return
+
         redis_client = get_redis_instance()
         if redis_client:
             try:
                 cached_response = redis_client.get(cache_key)
                 if cached_response:
                     logger.info(f"Cache hit for stream key: {cache_key}")
-                    cached_response = json.loads(cached_response.decode('utf-8'))
+                    cached_response = json.loads(cached_response.decode("utf-8"))
                     for chunk in cached_response:
                         yield chunk
-                        time.sleep(0.03)
+                        time.sleep(0.03)  # Simulate streaming delay
                     return
-            except redis.ConnectionError as e:
-                logger.error(f"Redis connection error: {e}")
+            except Exception as e:
+                logger.error(f"Error getting cached stream: {e}")
 
-        result = func(self, model, messages, stream, *args, **kwargs)
         stream_cache_data = []
-        
-        for chunk in result:
-            stream_cache_data.append(chunk)
+        for chunk in func(self, model, messages, stream, tools, *args, **kwargs):
             yield chunk
-        
+            stream_cache_data.append(str(chunk))
+
         if redis_client:
             try:
                 redis_client.set(cache_key, json.dumps(stream_cache_data), ex=1800)
                 logger.info(f"Stream cache saved for key: {cache_key}")
-            except redis.ConnectionError as e:
-                logger.error(f"Redis connection error: {e}")
-        
-    return wrapper
+            except Exception as e:
+                logger.error(f"Error setting stream cache: {e}")
+
+    return wrapper

application/celery_init.py

@@ -2,14 +2,22 @@ from celery import Celery
 from application.core.settings import settings
 from celery.signals import setup_logging
 
+
 def make_celery(app_name=__name__):
-    celery = Celery(app_name, broker=settings.CELERY_BROKER_URL, backend=settings.CELERY_RESULT_BACKEND)
+    celery = Celery(
+        app_name,
+        broker=settings.CELERY_BROKER_URL,
+        backend=settings.CELERY_RESULT_BACKEND,
+    )
     celery.conf.update(settings)
     return celery
 
+
 @setup_logging.connect
 def config_loggers(*args, **kwargs):
     from application.core.logging_config import setup_logging
+
     setup_logging()
 
+
 celery = make_celery()

application/core/settings.py

@@ -1,25 +1,39 @@
+import os
 from pathlib import Path
 from typing import Optional
-import os
 
 from pydantic_settings import BaseSettings
 
-current_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+current_dir = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+)
 
 
 class Settings(BaseSettings):
+    AUTH_TYPE: Optional[str] = None
     LLM_NAME: str = "docsgpt"
-    MODEL_NAME: Optional[str] = None # if LLM_NAME is openai, MODEL_NAME can be gpt-4 or gpt-3.5-turbo
+    MODEL_NAME: Optional[str] = (
+        None  # if LLM_NAME is openai, MODEL_NAME can be gpt-4 or gpt-3.5-turbo
+    )
     EMBEDDINGS_NAME: str = "huggingface_sentence-transformers/all-mpnet-base-v2"
     CELERY_BROKER_URL: str = "redis://localhost:6379/0"
     CELERY_RESULT_BACKEND: str = "redis://localhost:6379/1"
     MONGO_URI: str = "mongodb://localhost:27017/docsgpt"
     MODEL_PATH: str = os.path.join(current_dir, "models/docsgpt-7b-f16.gguf")
     DEFAULT_MAX_HISTORY: int = 150
-    MODEL_TOKEN_LIMITS: dict = {"gpt-3.5-turbo": 4096, "claude-2": 1e5}
+    MODEL_TOKEN_LIMITS: dict = {
+        "gpt-4o-mini": 128000,
+        "gpt-3.5-turbo": 4096,
+        "claude-2": 1e5,
+        "gemini-2.0-flash-exp": 1e6,
+    }
     UPLOAD_FOLDER: str = "inputs"
-    VECTOR_STORE: str = "faiss" #  "faiss" or "elasticsearch" or "qdrant" or "milvus" or "lancedb"
-    RETRIEVERS_ENABLED: list = ["classic_rag", "duckduck_search"] # also brave_search
+    PARSE_PDF_AS_IMAGE: bool = False
+    VECTOR_STORE: str = (
+        "faiss"  #  "faiss" or "elasticsearch" or "qdrant" or "milvus" or "lancedb"
+    )
+    RETRIEVERS_ENABLED: list = ["classic_rag", "duckduck_search"]  # also brave_search
+    AGENT_NAME: str = "classic"
 
     # LLM Cache
     CACHE_REDIS_URL: str = "redis://localhost:6379/2"
@@ -27,12 +41,18 @@ class Settings(BaseSettings):
     API_URL: str = "http://localhost:7091"  # backend url for celery worker
 
     API_KEY: Optional[str] = None  # LLM api key
-    EMBEDDINGS_KEY: Optional[str] = None  # api key for embeddings (if using openai, just copy API_KEY)
+    EMBEDDINGS_KEY: Optional[str] = (
+        None  # api key for embeddings (if using openai, just copy API_KEY)
+    )
     OPENAI_API_BASE: Optional[str] = None  # azure openai api base url
     OPENAI_API_VERSION: Optional[str] = None  # azure openai api version
     AZURE_DEPLOYMENT_NAME: Optional[str] = None  # azure deployment name for answering
-    AZURE_EMBEDDINGS_DEPLOYMENT_NAME: Optional[str] = None  # azure deployment name for embeddings
-    OPENAI_BASE_URL: Optional[str] = None # openai base url for open ai compatable models
+    AZURE_EMBEDDINGS_DEPLOYMENT_NAME: Optional[str] = (
+        None  # azure deployment name for embeddings
+    )
+    OPENAI_BASE_URL: Optional[str] = (
+        None  # openai base url for open ai compatable models
+    )
 
     # elasticsearch
     ELASTIC_CLOUD_ID: Optional[str] = None  # cloud id for elasticsearch
@@ -67,16 +87,20 @@ class Settings(BaseSettings):
 
     # Milvus vectorstore config
     MILVUS_COLLECTION_NAME: Optional[str] = "docsgpt"
-    MILVUS_URI: Optional[str] = "./milvus_local.db"   # milvus lite version as default
+    MILVUS_URI: Optional[str] = "./milvus_local.db"  # milvus lite version as default
     MILVUS_TOKEN: Optional[str] = ""
 
     # LanceDB vectorstore config
     LANCEDB_PATH: str = "/tmp/lancedb"  # Path where LanceDB stores its local data
-    LANCEDB_TABLE_NAME: Optional[str] = "docsgpts"  # Name of the table to use for storing vectors
+    LANCEDB_TABLE_NAME: Optional[str] = (
+        "docsgpts"  # Name of the table to use for storing vectors
+    )
     BRAVE_SEARCH_API_KEY: Optional[str] = None
 
     FLASK_DEBUG_MODE: bool = False
 
+    JWT_SECRET_KEY: str = ""
+
 
 path = Path(__file__).parent.parent.absolute()
 settings = Settings(_env_file=path.joinpath(".env"), _env_file_encoding="utf-8")

application/llm/anthropic.py

@@ -17,7 +17,7 @@ class AnthropicLLM(BaseLLM):
         self.AI_PROMPT = AI_PROMPT
 
     def _raw_gen(
-        self, baseself, model, messages, stream=False, max_tokens=300, **kwargs
+        self, baseself, model, messages, stream=False, tools=None, max_tokens=300, **kwargs
     ):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
@@ -34,7 +34,7 @@ class AnthropicLLM(BaseLLM):
         return completion.completion
 
     def _raw_gen_stream(
-        self, baseself, model, messages, stream=True, max_tokens=300, **kwargs
+        self, baseself, model, messages, stream=True, tools=None, max_tokens=300, **kwargs
     ):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]

application/llm/base.py

@@ -1,10 +1,12 @@
 from abc import ABC, abstractmethod
+
+from application.cache import gen_cache, stream_cache
 from application.usage import gen_token_usage, stream_token_usage
-from application.cache import stream_cache, gen_cache
 
 
 class BaseLLM(ABC):
-    def __init__(self):
+    def __init__(self, decoded_token=None):
+        self.decoded_token = decoded_token
         self.token_usage = {"prompt_tokens": 0, "generated_tokens": 0}
 
     def _apply_decorator(self, method, decorators, *args, **kwargs):
@@ -13,17 +15,43 @@ class BaseLLM(ABC):
         return method(self, *args, **kwargs)
 
     @abstractmethod
-    def _raw_gen(self, model, messages, stream, *args, **kwargs):
+    def _raw_gen(self, model, messages, stream, tools, *args, **kwargs):
         pass
 
-    def gen(self, model, messages, stream=False, *args, **kwargs):
+    def gen(self, model, messages, stream=False, tools=None, *args, **kwargs):
         decorators = [gen_token_usage, gen_cache]
-        return self._apply_decorator(self._raw_gen, decorators=decorators, model=model, messages=messages, stream=stream, *args, **kwargs)
+        return self._apply_decorator(
+            self._raw_gen,
+            decorators=decorators,
+            model=model,
+            messages=messages,
+            stream=stream,
+            tools=tools,
+            *args,
+            **kwargs
+        )
 
     @abstractmethod
     def _raw_gen_stream(self, model, messages, stream, *args, **kwargs):
         pass
 
-    def gen_stream(self, model, messages, stream=True, *args, **kwargs):
+    def gen_stream(self, model, messages, stream=True, tools=None, *args, **kwargs):
         decorators = [stream_cache, stream_token_usage]
-        return self._apply_decorator(self._raw_gen_stream, decorators=decorators, model=model, messages=messages, stream=stream, *args, **kwargs)
+        return self._apply_decorator(
+            self._raw_gen_stream,
+            decorators=decorators,
+            model=model,
+            messages=messages,
+            stream=stream,
+            tools=tools,
+            *args,
+            **kwargs
+        )
+
+    def supports_tools(self):
+        return hasattr(self, "_supports_tools") and callable(
+            getattr(self, "_supports_tools")
+        )
+
+    def _supports_tools(self):
+        raise NotImplementedError("Subclass must implement _supports_tools method")

application/llm/docsgpt_provider.py

@@ -1,34 +1,131 @@
-from application.llm.base import BaseLLM
 import json
-import requests
+
+from application.core.settings import settings
+from application.llm.base import BaseLLM
 
 
 class DocsGPTAPILLM(BaseLLM):
 
     def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
+        from openai import OpenAI
+
         super().__init__(*args, **kwargs)
-        self.api_key = api_key
+        self.client = OpenAI(api_key="sk-docsgpt-public", base_url="https://oai.arc53.com")
         self.user_api_key = user_api_key
-        self.endpoint = "https://llm.arc53.com"
+        self.api_key = api_key
 
-    def _raw_gen(self, baseself, model, messages, stream=False, *args, **kwargs):
-        response = requests.post(
-            f"{self.endpoint}/answer", json={"messages": messages, "max_new_tokens": 30}
-        )
-        response_clean = response.json()["a"].replace("###", "")
+    def _clean_messages_openai(self, messages):
+        cleaned_messages = []
+        for message in messages:
+            role = message.get("role")
+            content = message.get("content")
 
-        return response_clean
+            if role == "model":
+                role = "assistant"
 
-    def _raw_gen_stream(self, baseself, model, messages, stream=True, *args, **kwargs):
-        response = requests.post(
-            f"{self.endpoint}/stream",
-            json={"messages": messages, "max_new_tokens": 256},
-            stream=True,
-        )
+            if role and content is not None:
+                if isinstance(content, str):
+                    cleaned_messages.append({"role": role, "content": content})
+                elif isinstance(content, list):
+                    for item in content:
+                        if "text" in item:
+                            cleaned_messages.append(
+                                {"role": role, "content": item["text"]}
+                            )
+                        elif "function_call" in item:
+                            tool_call = {
+                                "id": item["function_call"]["call_id"],
+                                "type": "function",
+                                "function": {
+                                    "name": item["function_call"]["name"],
+                                    "arguments": json.dumps(
+                                        item["function_call"]["args"]
+                                    ),
+                                },
+                            }
+                            cleaned_messages.append(
+                                {
+                                    "role": "assistant",
+                                    "content": None,
+                                    "tool_calls": [tool_call],
+                                }
+                            )
+                        elif "function_response" in item:
+                            cleaned_messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": item["function_response"][
+                                        "call_id"
+                                    ],
+                                    "content": json.dumps(
+                                        item["function_response"]["response"]["result"]
+                                    ),
+                                }
+                            )
+                        else:
+                            raise ValueError(
+                                f"Unexpected content dictionary format: {item}"
+                            )
+                else:
+                    raise ValueError(f"Unexpected content type: {type(content)}")
 
-        for line in response.iter_lines():
-            if line:
-                data_str = line.decode("utf-8")
-                if data_str.startswith("data: "):
-                    data = json.loads(data_str[6:])
-                    yield data["a"]
+        return cleaned_messages
+
+    def _raw_gen(
+        self,
+        baseself,
+        model,
+        messages,
+        stream=False,
+        tools=None,
+        engine=settings.AZURE_DEPLOYMENT_NAME,
+        **kwargs,
+    ):
+        messages = self._clean_messages_openai(messages)
+        if tools:
+            response = self.client.chat.completions.create(
+                model="docsgpt",
+                messages=messages,
+                stream=stream,
+                tools=tools,
+                **kwargs,
+            )
+            return response.choices[0]
+        else:
+            response = self.client.chat.completions.create(
+                model="docsgpt", messages=messages, stream=stream, **kwargs
+            )
+            return response.choices[0].message.content
+
+    def _raw_gen_stream(
+        self,
+        baseself,
+        model,
+        messages,
+        stream=True,
+        tools=None,
+        engine=settings.AZURE_DEPLOYMENT_NAME,
+        **kwargs,
+    ):
+        messages = self._clean_messages_openai(messages)
+        if tools:
+            response = self.client.chat.completions.create(
+                model="docsgpt",
+                messages=messages,
+                stream=stream,
+                tools=tools,
+                **kwargs,
+            )
+        else:
+            response = self.client.chat.completions.create(
+                model="docsgpt", messages=messages, stream=stream, **kwargs
+            )
+
+        for line in response:
+            if len(line.choices) > 0 and line.choices[0].delta.content is not None and len(line.choices[0].delta.content) > 0:
+                yield line.choices[0].delta.content
+            elif len(line.choices) > 0:
+                yield line.choices[0]
+
+    def _supports_tools(self):
+        return True

application/llm/google_ai.py

@@ -1,21 +1,95 @@
+from google import genai
+from google.genai import types
+
 from application.llm.base import BaseLLM
 
+
 class GoogleLLM(BaseLLM):
-
     def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
-
         super().__init__(*args, **kwargs)
         self.api_key = api_key
         self.user_api_key = user_api_key
 
     def _clean_messages_google(self, messages):
-        return [
-            {
-                "role": "model" if message["role"] == "system" else message["role"],
-                "parts": [message["content"]],
-            }
-            for message in messages[1:]
-        ]
+        cleaned_messages = []
+        for message in messages:
+            role = message.get("role")
+            content = message.get("content")
+
+            if role == "assistant":
+                role = "model"
+
+            parts = []
+            if role and content is not None:
+                if isinstance(content, str):
+                    parts = [types.Part.from_text(text=content)]
+                elif isinstance(content, list):
+                    for item in content:
+                        if "text" in item:
+                            parts.append(types.Part.from_text(item["text"]))
+                        elif "function_call" in item:
+                            parts.append(
+                                types.Part.from_function_call(
+                                    name=item["function_call"]["name"],
+                                    args=item["function_call"]["args"],
+                                )
+                            )
+                        elif "function_response" in item:
+                            parts.append(
+                                types.Part.from_function_response(
+                                    name=item["function_response"]["name"],
+                                    response=item["function_response"]["response"],
+                                )
+                            )
+                        else:
+                            raise ValueError(
+                                f"Unexpected content dictionary format:{item}"
+                            )
+                else:
+                    raise ValueError(f"Unexpected content type: {type(content)}")
+
+                cleaned_messages.append(types.Content(role=role, parts=parts))
+
+        return cleaned_messages
+
+    def _clean_tools_format(self, tools_list):
+        genai_tools = []
+        for tool_data in tools_list:
+            if tool_data["type"] == "function":
+                function = tool_data["function"]
+                parameters = function["parameters"]
+                properties = parameters.get("properties", {})
+
+                if properties:
+                    genai_function = dict(
+                        name=function["name"],
+                        description=function["description"],
+                        parameters={
+                            "type": "OBJECT",
+                            "properties": {
+                                k: {
+                                    **v,
+                                    "type": v["type"].upper() if v["type"] else None,
+                                }
+                                for k, v in properties.items()
+                            },
+                            "required": (
+                                parameters["required"]
+                                if "required" in parameters
+                                else []
+                            ),
+                        },
+                    )
+                else:
+                    genai_function = dict(
+                        name=function["name"],
+                        description=function["description"],
+                    )
+
+                genai_tool = types.Tool(function_declarations=[genai_function])
+                genai_tools.append(genai_tool)
+
+        return genai_tools
 
     def _raw_gen(
         self,
@@ -23,13 +97,32 @@ class GoogleLLM(BaseLLM):
         model,
         messages,
         stream=False,
-        **kwargs
-    ):  
-        import google.generativeai as genai
-        genai.configure(api_key=self.api_key)
-        model = genai.GenerativeModel(model, system_instruction=messages[0]["content"])
-        response = model.generate_content(self._clean_messages_google(messages))
-        return response.text
+        tools=None,
+        formatting="openai",
+        **kwargs,
+    ):
+        client = genai.Client(api_key=self.api_key)
+        if formatting == "openai":
+            messages = self._clean_messages_google(messages)
+        config = types.GenerateContentConfig()
+        if messages[0].role == "system":
+            config.system_instruction = messages[0].parts[0].text
+            messages = messages[1:]
+
+        if tools:
+            cleaned_tools = self._clean_tools_format(tools)
+            config.tools = cleaned_tools
+            response = client.models.generate_content(
+                model=model,
+                contents=messages,
+                config=config,
+            )
+            return response
+        else:
+            response = client.models.generate_content(
+                model=model, contents=messages, config=config
+            )
+            return response.text
 
     def _raw_gen_stream(
         self,
@@ -37,12 +130,38 @@ class GoogleLLM(BaseLLM):
         model,
         messages,
         stream=True,
-        **kwargs
-    ):  
-        import google.generativeai as genai
-        genai.configure(api_key=self.api_key)
-        model = genai.GenerativeModel(model, system_instruction=messages[0]["content"])
-        response = model.generate_content(self._clean_messages_google(messages), stream=True)
-        for line in response:
-            if line.text is not None:
-                yield line.text
+        tools=None,
+        formatting="openai",
+        **kwargs,
+    ):
+        client = genai.Client(api_key=self.api_key)
+        if formatting == "openai":
+            messages = self._clean_messages_google(messages)
+        config = types.GenerateContentConfig()
+        if messages[0].role == "system":
+            config.system_instruction = messages[0].parts[0].text
+            messages = messages[1:]
+
+        if tools:
+            cleaned_tools = self._clean_tools_format(tools)
+            config.tools = cleaned_tools
+
+        response = client.models.generate_content_stream(
+            model=model,
+            contents=messages,
+            config=config,
+        )
+        for chunk in response:
+            if hasattr(chunk, "candidates") and chunk.candidates:
+                for candidate in chunk.candidates:
+                    if candidate.content and candidate.content.parts:
+                        for part in candidate.content.parts:
+                            if part.function_call:
+                                yield part
+                            elif part.text:
+                                yield part.text
+            elif hasattr(chunk, "text"):
+                yield chunk.text
+
+    def _supports_tools(self):
+        return True

application/llm/groq.py

@@ -1,45 +1,32 @@
 from application.llm.base import BaseLLM
-
+from openai import OpenAI
 
 
 class GroqLLM(BaseLLM):
-
     def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
-        from openai import OpenAI
-
         super().__init__(*args, **kwargs)
         self.client = OpenAI(api_key=api_key, base_url="https://api.groq.com/openai/v1")
         self.api_key = api_key
         self.user_api_key = user_api_key
 
-    def _raw_gen(
-        self,
-        baseself,
-        model,
-        messages,
-        stream=False,
-        **kwargs
-    ):  
-        response = self.client.chat.completions.create(
-            model=model, messages=messages, stream=stream, **kwargs
-        )
-
-        return response.choices[0].message.content
+    def _raw_gen(self, baseself, model, messages, stream=False, tools=None, **kwargs):
+        if tools:
+            response = self.client.chat.completions.create(
+                model=model, messages=messages, stream=stream, tools=tools, **kwargs
+            )
+            return response.choices[0]
+        else:
+            response = self.client.chat.completions.create(
+                model=model, messages=messages, stream=stream, **kwargs
+            )
+            return response.choices[0].message.content
 
     def _raw_gen_stream(
-        self,
-        baseself,
-        model,
-        messages,
-        stream=True,
-        **kwargs
-    ):  
+        self, baseself, model, messages, stream=True, tools=None, **kwargs
+    ):
         response = self.client.chat.completions.create(
             model=model, messages=messages, stream=stream, **kwargs
         )
-
         for line in response:
-            # import sys
-            # print(line.choices[0].delta.content, file=sys.stderr)
             if line.choices[0].delta.content is not None:
                 yield line.choices[0].delta.content

application/llm/llm_creator.py

@@ -7,6 +7,7 @@ from application.llm.anthropic import AnthropicLLM
 from application.llm.docsgpt_provider import DocsGPTAPILLM
 from application.llm.premai import PremAILLM
 from application.llm.google_ai import GoogleLLM
+from application.llm.novita import NovitaLLM
 
 
 class LLMCreator:
@@ -20,12 +21,15 @@ class LLMCreator:
         "docsgpt": DocsGPTAPILLM,
         "premai": PremAILLM,
         "groq": GroqLLM,
-        "google": GoogleLLM
+        "google": GoogleLLM,
+        "novita": NovitaLLM,
     }
 
     @classmethod
-    def create_llm(cls, type, api_key, user_api_key, *args, **kwargs):
+    def create_llm(cls, type, api_key, user_api_key, decoded_token, *args, **kwargs):
         llm_class = cls.llms.get(type.lower())
         if not llm_class:
             raise ValueError(f"No LLM class found for type {type}")
-        return llm_class(api_key, user_api_key, *args, **kwargs)
+        return llm_class(
+            api_key, user_api_key, decoded_token=decoded_token, *args, **kwargs
+        )

application/llm/novita.py

@@ -0,0 +1,32 @@
+from application.llm.base import BaseLLM
+from openai import OpenAI
+
+
+class NovitaLLM(BaseLLM):
+    def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.client = OpenAI(api_key=api_key, base_url="https://api.novita.ai/v3/openai")
+        self.api_key = api_key
+        self.user_api_key = user_api_key
+
+    def _raw_gen(self, baseself, model, messages, stream=False, tools=None, **kwargs):
+        if tools:
+            response = self.client.chat.completions.create(
+                model=model, messages=messages, stream=stream, tools=tools, **kwargs
+            )
+            return response.choices[0]
+        else:
+            response = self.client.chat.completions.create(
+                model=model, messages=messages, stream=stream, **kwargs
+            )
+            return response.choices[0].message.content
+
+    def _raw_gen_stream(
+        self, baseself, model, messages, stream=True, tools=None, **kwargs
+    ):
+        response = self.client.chat.completions.create(
+            model=model, messages=messages, stream=stream, **kwargs
+        )
+        for line in response:
+            if line.choices[0].delta.content is not None:
+                yield line.choices[0].delta.content

application/llm/openai.py

@@ -1,6 +1,7 @@
-from application.llm.base import BaseLLM
-from application.core.settings import settings
+import json
 
+from application.core.settings import settings
+from application.llm.base import BaseLLM
 
 
 class OpenAILLM(BaseLLM):
@@ -10,29 +11,94 @@ class OpenAILLM(BaseLLM):
 
         super().__init__(*args, **kwargs)
         if settings.OPENAI_BASE_URL:
-            self.client = OpenAI(
-                api_key=api_key,
-                base_url=settings.OPENAI_BASE_URL
-            )
+            self.client = OpenAI(api_key=api_key, base_url=settings.OPENAI_BASE_URL)
         else:
             self.client = OpenAI(api_key=api_key)
         self.api_key = api_key
         self.user_api_key = user_api_key
 
+    def _clean_messages_openai(self, messages):
+        cleaned_messages = []
+        for message in messages:
+            role = message.get("role")
+            content = message.get("content")
+
+            if role == "model":
+                role = "assistant"
+
+            if role and content is not None:
+                if isinstance(content, str):
+                    cleaned_messages.append({"role": role, "content": content})
+                elif isinstance(content, list):
+                    for item in content:
+                        if "text" in item:
+                            cleaned_messages.append(
+                                {"role": role, "content": item["text"]}
+                            )
+                        elif "function_call" in item:
+                            tool_call = {
+                                "id": item["function_call"]["call_id"],
+                                "type": "function",
+                                "function": {
+                                    "name": item["function_call"]["name"],
+                                    "arguments": json.dumps(
+                                        item["function_call"]["args"]
+                                    ),
+                                },
+                            }
+                            cleaned_messages.append(
+                                {
+                                    "role": "assistant",
+                                    "content": None,
+                                    "tool_calls": [tool_call],
+                                }
+                            )
+                        elif "function_response" in item:
+                            cleaned_messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": item["function_response"][
+                                        "call_id"
+                                    ],
+                                    "content": json.dumps(
+                                        item["function_response"]["response"]["result"]
+                                    ),
+                                }
+                            )
+                        else:
+                            raise ValueError(
+                                f"Unexpected content dictionary format: {item}"
+                            )
+                else:
+                    raise ValueError(f"Unexpected content type: {type(content)}")
+
+        return cleaned_messages
+
     def _raw_gen(
         self,
         baseself,
         model,
         messages,
         stream=False,
+        tools=None,
         engine=settings.AZURE_DEPLOYMENT_NAME,
-        **kwargs
-    ):  
-        response = self.client.chat.completions.create(
-            model=model, messages=messages, stream=stream, **kwargs
-        )
-
-        return response.choices[0].message.content
+        **kwargs,
+    ):
+        messages = self._clean_messages_openai(messages)
+        if tools:
+            response = self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                stream=stream,
+                tools=tools,
+                **kwargs,
+            )
+            return response.choices[0]
+        else:
+            response = self.client.chat.completions.create(
+                model=model, messages=messages, stream=stream, **kwargs
+            )
+            return response.choices[0].message.content
 
     def _raw_gen_stream(
         self,
@@ -40,34 +106,48 @@ class OpenAILLM(BaseLLM):
         model,
         messages,
         stream=True,
+        tools=None,
         engine=settings.AZURE_DEPLOYMENT_NAME,
-        **kwargs
-    ):  
-        response = self.client.chat.completions.create(
-            model=model, messages=messages, stream=stream, **kwargs
-        )
+        **kwargs,
+    ):
+        messages = self._clean_messages_openai(messages)
+        if tools:
+            response = self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                stream=stream,
+                tools=tools,
+                **kwargs,
+            )
+        else:
+            response = self.client.chat.completions.create(
+                model=model, messages=messages, stream=stream, **kwargs
+            )
 
         for line in response:
-            # import sys
-            # print(line.choices[0].delta.content, file=sys.stderr)
-            if line.choices[0].delta.content is not None:
+            if len(line.choices) > 0 and line.choices[0].delta.content is not None and len(line.choices[0].delta.content) > 0:
                 yield line.choices[0].delta.content
+            elif len(line.choices) > 0:
+                yield line.choices[0]
+
+    def _supports_tools(self):
+        return True
 
 
 class AzureOpenAILLM(OpenAILLM):
 
     def __init__(
-        self, openai_api_key, openai_api_base, openai_api_version, deployment_name
+        self, api_key, user_api_key, *args, **kwargs 
     ):
-        super().__init__(openai_api_key)
+
+        super().__init__(api_key)
         self.api_base = (settings.OPENAI_API_BASE,)
         self.api_version = (settings.OPENAI_API_VERSION,)
         self.deployment_name = (settings.AZURE_DEPLOYMENT_NAME,)
         from openai import AzureOpenAI
 
         self.client = AzureOpenAI(
-            api_key=openai_api_key,
+            api_key=api_key,
             api_version=settings.OPENAI_API_VERSION,
-            api_base=settings.OPENAI_API_BASE,
-            deployment_name=settings.AZURE_DEPLOYMENT_NAME,
+            azure_endpoint=settings.OPENAI_API_BASE
         )

application/llm/sagemaker.py

@@ -76,7 +76,7 @@ class SagemakerAPILLM(BaseLLM):
         self.endpoint = settings.SAGEMAKER_ENDPOINT
         self.runtime = runtime
 
-    def _raw_gen(self, baseself, model, messages, stream=False, **kwargs):
+    def _raw_gen(self, baseself, model, messages, stream=False, tools=None, **kwargs):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
         prompt = f"### Instruction \n {user_question} \n ### Context \n {context} \n ### Answer \n"
@@ -105,7 +105,7 @@ class SagemakerAPILLM(BaseLLM):
         print(result[0]["generated_text"], file=sys.stderr)
         return result[0]["generated_text"][len(prompt) :]
 
-    def _raw_gen_stream(self, baseself, model, messages, stream=True, **kwargs):
+    def _raw_gen_stream(self, baseself, model, messages, stream=True, tools=None, **kwargs):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
         prompt = f"### Instruction \n {user_question} \n ### Context \n {context} \n ### Answer \n"

application/logging.py

@@ -0,0 +1,151 @@
+import datetime
+import functools
+import inspect
+
+import logging
+import uuid
+from typing import Any, Callable, Dict, Generator, List
+
+from application.core.mongo_db import MongoDB
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+
+class LogContext:
+    def __init__(self, endpoint, activity_id, user, api_key, query):
+        self.endpoint = endpoint
+        self.activity_id = activity_id
+        self.user = user
+        self.api_key = api_key
+        self.query = query
+        self.stacks = []
+
+
+def build_stack_data(
+    obj: Any,
+    include_attributes: List[str] = None,
+    exclude_attributes: List[str] = None,
+    custom_data: Dict = None,
+) -> Dict:
+    data = {}
+    if include_attributes is None:
+        include_attributes = []
+        for name, value in inspect.getmembers(obj):
+            if (
+                not name.startswith("_")
+                and not inspect.ismethod(value)
+                and not inspect.isfunction(value)
+            ):
+                include_attributes.append(name)
+    for attr_name in include_attributes:
+        if exclude_attributes and attr_name in exclude_attributes:
+            continue
+        try:
+            attr_value = getattr(obj, attr_name)
+            if attr_value is not None:
+                if isinstance(attr_value, (int, float, str, bool)):
+                    data[attr_name] = attr_value
+                elif isinstance(attr_value, list):
+                    if all(isinstance(item, dict) for item in attr_value):
+                        data[attr_name] = attr_value
+                    elif all(hasattr(item, "__dict__") for item in attr_value):
+                        data[attr_name] = [item.__dict__ for item in attr_value]
+                    else:
+                        data[attr_name] = [str(item) for item in attr_value]
+                elif isinstance(attr_value, dict):
+                    data[attr_name] = {k: str(v) for k, v in attr_value.items()}
+                else:
+                    data[attr_name] = str(attr_value)
+        except AttributeError:
+            pass
+    if custom_data:
+        data.update(custom_data)
+    return data
+
+
+def log_activity() -> Callable:
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            activity_id = str(uuid.uuid4())
+            data = build_stack_data(args[0])
+            endpoint = data.get("endpoint", "")
+            user = data.get("user", "local")
+            api_key = data.get("user_api_key", "")
+            query = kwargs.get("query", getattr(args[0], "query", ""))
+
+            context = LogContext(endpoint, activity_id, user, api_key, query)
+            kwargs["log_context"] = context
+
+            logging.info(
+                f"Starting activity: {endpoint} - {activity_id} - User: {user}"
+            )
+
+            generator = func(*args, **kwargs)
+            yield from _consume_and_log(generator, context)
+
+        return wrapper
+
+    return decorator
+
+
+def _consume_and_log(generator: Generator, context: "LogContext"):
+    try:
+        for item in generator:
+            yield item
+    except Exception as e:
+        logging.exception(f"Error in {context.endpoint} - {context.activity_id}: {e}")
+        context.stacks.append({"component": "error", "data": {"message": str(e)}})
+        _log_to_mongodb(
+            endpoint=context.endpoint,
+            activity_id=context.activity_id,
+            user=context.user,
+            api_key=context.api_key,
+            query=context.query,
+            stacks=context.stacks,
+            level="error",
+        )
+        raise
+    finally:
+        _log_to_mongodb(
+            endpoint=context.endpoint,
+            activity_id=context.activity_id,
+            user=context.user,
+            api_key=context.api_key,
+            query=context.query,
+            stacks=context.stacks,
+            level="info",
+        )
+
+
+def _log_to_mongodb(
+    endpoint: str,
+    activity_id: str,
+    user: str,
+    api_key: str,
+    query: str,
+    stacks: List[Dict],
+    level: str,
+) -> None:
+    try:
+        mongo = MongoDB.get_client()
+        db = mongo["docsgpt"]
+        user_logs_collection = db["stack_logs"]
+
+        log_entry = {
+            "endpoint": endpoint,
+            "id": activity_id,
+            "level": level,
+            "user": user,
+            "api_key": api_key,
+            "query": query,
+            "stacks": stacks,
+            "timestamp": datetime.datetime.now(datetime.timezone.utc),
+        }
+        user_logs_collection.insert_one(log_entry)
+        logging.debug(f"Logged activity to MongoDB: {activity_id}")
+
+    except Exception as e:
+        logging.error(f"Failed to log to MongoDB: {e}")

application/parser/chunking.py

@@ -1,5 +1,5 @@
 import re
-from typing import List, Tuple, Union
+from typing import List, Tuple
 import logging
 from application.parser.schema.base import Document
 from application.utils import get_encoding

application/parser/embedding_pipeline.py

@@ -61,7 +61,7 @@ def embed_and_store_documents(docs, folder_name, source_id, task_status):
 
     # Process and embed documents
     for idx, doc in tqdm(
-        docs,
+        enumerate(docs),
         desc="Embedding 🦖",
         unit="docs",
         total=total_docs,
@@ -69,7 +69,7 @@ def embed_and_store_documents(docs, folder_name, source_id, task_status):
     ):
         try:
             # Update task status for progress tracking
-            progress = int((idx / total_docs) * 100)
+            progress = int(((idx + 1) / total_docs) * 100)
             task_status.update_state(state="PROGRESS", meta={"current": progress})
 
             # Add document to vector store

application/parser/file/bulk.py

@@ -13,6 +13,7 @@ from application.parser.file.rst_parser import RstParser
 from application.parser.file.tabular_parser import PandasCSVParser,ExcelParser
 from application.parser.file.json_parser import JSONParser
 from application.parser.file.pptx_parser import PPTXParser
+from application.parser.file.image_parser import ImageParser
 from application.parser.schema.base import Document
 
 DEFAULT_FILE_EXTRACTOR: Dict[str, BaseParser] = {
@@ -27,6 +28,9 @@ DEFAULT_FILE_EXTRACTOR: Dict[str, BaseParser] = {
     ".mdx": MarkdownParser(),
     ".json":JSONParser(),
     ".pptx":PPTXParser(),
+    ".png": ImageParser(),
+    ".jpg": ImageParser(),
+    ".jpeg": ImageParser(),
 }
 
 

application/parser/file/docs_parser.py

@@ -7,7 +7,8 @@ from pathlib import Path
 from typing import Dict
 
 from application.parser.file.base_parser import BaseParser
-
+from application.core.settings import settings
+import requests
 
 class PDFParser(BaseParser):
     """PDF parser."""
@@ -18,22 +19,32 @@ class PDFParser(BaseParser):
 
     def parse_file(self, file: Path, errors: str = "ignore") -> str:
         """Parse file."""
+        if settings.PARSE_PDF_AS_IMAGE:
+            doc2md_service = "https://llm.arc53.com/doc2md"
+            # alternatively you can use local vision capable LLM
+            with open(file, "rb") as file_loaded:
+                files = {'file': file_loaded}
+                response = requests.post(doc2md_service, files=files)
+                data = response.json()["markdown"]
+            return data
+
         try:
-            import PyPDF2
+            from pypdf import PdfReader
         except ImportError:
-            raise ValueError("PyPDF2 is required to read PDF files.")
+            raise ValueError("pypdf is required to read PDF files.")
         text_list = []
         with open(file, "rb") as fp:
             # Create a PDF object
-            pdf = PyPDF2.PdfReader(fp)
+            pdf = PdfReader(fp)
 
             # Get the number of pages in the PDF document
             num_pages = len(pdf.pages)
 
             # Iterate over every page
-            for page in range(num_pages):
+            for page_index in range(num_pages):
                 # Extract the text from the page
-                page_text = pdf.pages[page].extract_text()
+                page = pdf.pages[page_index]
+                page_text = page.extract_text()
                 text_list.append(page_text)
         text = "\n".join(text_list)
 
@@ -56,4 +67,4 @@ class DocxParser(BaseParser):
 
         text = docx2txt.process(file)
 
-        return text
+        return text

application/parser/file/image_parser.py

@@ -0,0 +1,27 @@
+"""Image parser.
+
+Contains parser for .png, .jpg, .jpeg files.
+
+"""
+from pathlib import Path
+import requests
+from typing import Dict, Union
+
+from application.parser.file.base_parser import BaseParser
+
+
+class ImageParser(BaseParser):
+    """Image parser."""
+
+    def _init_parser(self) -> Dict:
+        """Init parser."""
+        return {}
+
+    def parse_file(self, file: Path, errors: str = "ignore") -> Union[str, list[str]]:
+        doc2md_service = "https://llm.arc53.com/doc2md"
+        # alternatively you can use local vision capable LLM
+        with open(file, "rb") as file_loaded:
+            files = {'file': file_loaded}
+            response = requests.post(doc2md_service, files=files)   
+            data = response.json()["markdown"] 
+        return data

application/parser/file/rst_parser.py

@@ -91,6 +91,25 @@ class RstParser(BaseParser):
             ]
         return rst_tups
 
+    def chunk_by_token_count(self, text: str, max_tokens: int = 100) -> List[str]:
+        """Chunk text by token count."""
+    
+        avg_token_length = 5
+    
+        chunk_size = max_tokens * avg_token_length
+
+        chunks = []
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i+chunk_size]
+            if i + chunk_size < len(text):
+                last_space = chunk.rfind(' ')
+                if last_space != -1:
+                    chunk = chunk[:last_space]
+            
+            chunks.append(chunk.strip())
+        
+        return chunks
+    
     def remove_images(self, content: str) -> str:
         pattern = r"\.\. image:: (.*)"
         content = re.sub(pattern, "", content)
@@ -136,7 +155,7 @@ class RstParser(BaseParser):
         return {}
 
     def parse_tups(
-            self, filepath: Path, errors: str = "ignore"
+            self, filepath: Path, errors: str = "ignore",max_tokens: Optional[int] = 1000
     ) -> List[Tuple[Optional[str], str]]:
         """Parse file into tuples."""
         with open(filepath, "r") as f:
@@ -156,6 +175,15 @@ class RstParser(BaseParser):
             rst_tups = self.remove_whitespaces_excess(rst_tups)
         if self._remove_characters_excess:
             rst_tups = self.remove_characters_excess(rst_tups)
+
+        # Apply chunking if max_tokens is provided
+        if max_tokens is not None:
+            chunked_tups = []
+            for header, text in rst_tups:
+                chunks = self.chunk_by_token_count(text, max_tokens)
+                for idx, chunk in enumerate(chunks):
+                    chunked_tups.append((f"{header} - Chunk {idx + 1}", chunk))
+            return chunked_tups    
         return rst_tups
 
     def parse_file(

application/parser/late_chunking.py

@@ -1,94 +0,0 @@
-from typing import List, Tuple, Union, Optional
-from transformers import AutoTokenizer, AutoModel
-from sentence_transformers import SentenceTransformer
-import torch
-import torch.nn as nn
-from application.parser.schema.base import Document
-
-
-class LateChunker:
-    def __init__(self, model_name: str, late_tokens: int = 1000, **model_kwargs):
-        """
-        Initialize the LateChunker with a model, tokenizer, and late_tokens limit.
-        Supports both transformers and sentence-transformers models.
-        """
-        self.late_tokens = late_tokens
-        self.model_name = model_name
-
-        # Load model based on type
-        if "sentence-transformers" in model_name:
-            self.model = SentenceTransformer(model_name, **model_kwargs)
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-            self.wrapper_type = "sentence_transformers"
-        else:
-            self.model = AutoModel.from_pretrained(model_name, trust_remote_code=True, **model_kwargs)
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-            self.wrapper_type = "transformers"
-
-    def tokenize_with_offsets(self, text: str):
-        """Tokenize text and return tokens with character offsets."""
-        tokens = self.tokenizer.encode_plus(
-            text, return_offsets_mapping=True, add_special_tokens=False
-        )
-        return tokens["input_ids"], tokens["offset_mapping"]
-
-    def late_chunk_with_embeddings(
-        self, documents: List[Document]
-    ) -> List[Tuple[str, List[Tuple[int, int]], List[float]]]:
-        """
-        Combines documents into 'super chunks' that fit within `late_tokens` limit.
-        Outputs each super chunk with span annotations and embeddings.
-        """
-        super_chunks = []
-        current_super_chunk_text = []
-        current_token_count = 0
-        span_annotations = []
-
-        for doc in documents:
-            doc_text = doc.text
-            input_ids, offsets = self.tokenize_with_offsets(doc_text)
-            doc_token_count = len(input_ids)
-
-            # Check if adding this document exceeds the late_tokens limit
-            if current_token_count + doc_token_count > self.late_tokens:
-                # Finalize the current super chunk
-                combined_text = " ".join(current_super_chunk_text)
-                embeddings = self.generate_embeddings(combined_text)
-
-                super_chunks.append((combined_text, span_annotations, embeddings))
-
-                # Reset for a new super chunk
-                current_super_chunk_text = []
-                span_annotations = []
-                current_token_count = 0
-
-            # Add document to the current super chunk
-            start_token = current_token_count
-            end_token = current_token_count + doc_token_count
-            span_annotations.append((start_token, end_token))
-            current_super_chunk_text.append(doc_text)
-            current_token_count = end_token
-
-        # Add the final super chunk if there are remaining documents
-        if current_super_chunk_text:
-            combined_text = " ".join(current_super_chunk_text)
-            embeddings = self.generate_embeddings(combined_text)
-            super_chunks.append((combined_text, span_annotations, embeddings))
-
-        return super_chunks
-
-    def generate_embeddings(self, text: str) -> List[float]:
-        """Generate embeddings for a given text using the loaded model."""
-        if self.wrapper_type == "sentence_transformers":
-            # Sentence-Transformers
-            embeddings = self.model.encode([text])
-            return embeddings[0].tolist()
-
-        elif self.wrapper_type == "transformers":
-            # Transformers models
-            inputs = self.tokenizer(text, return_tensors="pt")
-            model_output = self.model(**inputs)
-            return model_output.last_hidden_state.mean(dim=1).squeeze().tolist()
-
-        else:
-            raise ValueError("Unsupported model type for embedding generation.")

application/parser/open_ai_func.py

@@ -1,75 +0,0 @@
-import os
-
-from retry import retry
-
-from application.core.settings import settings
-
-from application.vectorstore.vector_creator import VectorCreator
-
-
-# from langchain_community.embeddings import HuggingFaceEmbeddings
-# from langchain_community.embeddings import HuggingFaceInstructEmbeddings
-# from langchain_community.embeddings import CohereEmbeddings
-
-
-@retry(tries=10, delay=60)
-def store_add_texts_with_retry(store, i, id):
-    # add source_id to the metadata
-    i.metadata["source_id"] = str(id)
-    store.add_texts([i.page_content], metadatas=[i.metadata])
-    # store_pine.add_texts([i.page_content], metadatas=[i.metadata])
-
-
-def call_openai_api(docs, folder_name, id, task_status):
-    # Function to create a vector store from the documents and save it to disk
-
-    if not os.path.exists(f"{folder_name}"):
-        os.makedirs(f"{folder_name}")
-
-    from tqdm import tqdm
-
-    c1 = 0
-    if settings.VECTOR_STORE == "faiss":
-        docs_init = [docs[0]]
-        docs.pop(0)
-
-        store = VectorCreator.create_vectorstore(
-            settings.VECTOR_STORE,
-            docs_init=docs_init,
-            source_id=f"{folder_name}",
-            embeddings_key=os.getenv("EMBEDDINGS_KEY"),
-        )
-    else:
-        store = VectorCreator.create_vectorstore(
-            settings.VECTOR_STORE,
-            source_id=str(id),
-            embeddings_key=os.getenv("EMBEDDINGS_KEY"),
-        )
-        store.delete_index()
-    # Uncomment for MPNet embeddings
-    # model_name = "sentence-transformers/all-mpnet-base-v2"
-    # hf = HuggingFaceEmbeddings(model_name=model_name)
-    # store = FAISS.from_documents(docs_test, hf)
-    s1 = len(docs)
-    for i in tqdm(
-        docs,
-        desc="Embedding 🦖",
-        unit="docs",
-        total=len(docs),
-        bar_format="{l_bar}{bar}| Time Left: {remaining}",
-    ):
-        try:
-            task_status.update_state(
-                state="PROGRESS", meta={"current": int((c1 / s1) * 100)}
-            )
-            store_add_texts_with_retry(store, i, id)
-        except Exception as e:
-            print(e)
-            print("Error on ", i)
-            print("Saving progress")
-            print(f"stopped at {c1} out of {len(docs)}")
-            store.save_local(f"{folder_name}")
-            break
-        c1 += 1
-    if settings.VECTOR_STORE == "faiss":
-        store.save_local(f"{folder_name}")

application/parser/remote/crawler_loader.py

@@ -2,16 +2,16 @@ import requests
 from urllib.parse import urlparse, urljoin
 from bs4 import BeautifulSoup
 from application.parser.remote.base import BaseRemote
+from application.parser.schema.base import Document
+from langchain_community.document_loaders import WebBaseLoader
 
 class CrawlerLoader(BaseRemote):
     def __init__(self, limit=10):
-        from langchain_community.document_loaders import WebBaseLoader
         self.loader = WebBaseLoader  # Initialize the document loader
         self.limit = limit  # Set the limit for the number of pages to scrape
 
     def load_data(self, inputs):
         url = inputs
-        # Check if the input is a list and if it is, use the first element
         if isinstance(url, list) and url:
             url = url[0]
 
@@ -19,24 +19,29 @@ class CrawlerLoader(BaseRemote):
         if not urlparse(url).scheme:
             url = "http://" + url
 
-        visited_urls = set()  # Keep track of URLs that have been visited
-        base_url = urlparse(url).scheme + "://" + urlparse(url).hostname  # Extract the base URL
-        urls_to_visit = [url]  # List of URLs to be visited, starting with the initial URL
-        loaded_content = []  # Store the loaded content from each URL
+        visited_urls = set()
+        base_url = urlparse(url).scheme + "://" + urlparse(url).hostname
+        urls_to_visit = [url]
+        loaded_content = []
 
-        # Continue crawling until there are no more URLs to visit
         while urls_to_visit:
-            current_url = urls_to_visit.pop(0)  # Get the next URL to visit
-            visited_urls.add(current_url)  # Mark the URL as visited
+            current_url = urls_to_visit.pop(0)
+            visited_urls.add(current_url)
 
-            # Try to load and process the content from the current URL
             try:
-                response = requests.get(current_url)  # Fetch the content of the current URL
-                response.raise_for_status()  # Raise an exception for HTTP errors
-                loader = self.loader([current_url])  # Initialize the document loader for the current URL
-                loaded_content.extend(loader.load())  # Load the content and add it to the loaded_content list
+                response = requests.get(current_url)
+                response.raise_for_status()
+                loader = self.loader([current_url])
+                docs = loader.load()
+                # Convert the loaded documents to your Document schema
+                for doc in docs:
+                    loaded_content.append(
+                        Document(
+                            doc.page_content,
+                            extra_info=doc.metadata
+                        )
+                    )
             except Exception as e:
-                # Print an error message if loading or processing fails and continue with the next URL
                 print(f"Error processing URL {current_url}: {e}")
                 continue
 
@@ -45,15 +50,15 @@ class CrawlerLoader(BaseRemote):
             all_links = [
                 urljoin(current_url, a['href'])
                 for a in soup.find_all('a', href=True)
-                if base_url in urljoin(current_url, a['href'])  # Ensure links are from the same domain
+                if base_url in urljoin(current_url, a['href'])
             ]
 
             # Add new links to the list of URLs to visit if they haven't been visited yet
             urls_to_visit.extend([link for link in all_links if link not in visited_urls])
-            urls_to_visit = list(set(urls_to_visit))  # Remove duplicate URLs
+            urls_to_visit = list(set(urls_to_visit))
 
             # Stop crawling if the limit of pages to scrape is reached
             if self.limit is not None and len(visited_urls) >= self.limit:
                 break
 
-        return loaded_content  # Return the loaded content from all visited URLs
+        return loaded_content

application/parser/remote/crawler_markdown.py

@@ -0,0 +1,139 @@
+import requests
+from urllib.parse import urlparse, urljoin
+from bs4 import BeautifulSoup
+from application.parser.remote.base import BaseRemote
+import re
+from markdownify import markdownify
+from application.parser.schema.base import Document
+import tldextract
+
+class CrawlerLoader(BaseRemote):
+    def __init__(self, limit=10, allow_subdomains=False):
+        """
+        Given a URL crawl web pages up to `self.limit`,
+        convert HTML content to Markdown, and returning a list of Document objects.
+
+        :param limit: The maximum number of pages to crawl.
+        :param allow_subdomains: If True, crawl pages on subdomains of the base domain.
+        """
+        self.limit = limit
+        self.allow_subdomains = allow_subdomains
+        self.session = requests.Session()
+
+    def load_data(self, inputs):
+        url = inputs
+        if isinstance(url, list) and url:
+            url = url[0]
+
+        # Ensure the URL has a scheme (if not, default to http)
+        if not urlparse(url).scheme:
+            url = "http://" + url
+
+        # Keep track of visited URLs to avoid revisiting the same page
+        visited_urls = set()
+
+        # Determine the base domain for link filtering using tldextract
+        base_domain = self._get_base_domain(url)
+        urls_to_visit = {url}
+        documents = []
+
+        while urls_to_visit:
+            current_url = urls_to_visit.pop()
+
+            # Skip if already visited
+            if current_url in visited_urls:
+                continue
+            visited_urls.add(current_url)
+
+            # Fetch the page content
+            html_content = self._fetch_page(current_url)
+            if html_content is None:
+                continue
+
+            # Convert the HTML to Markdown for cleaner text formatting
+            title, language, processed_markdown = self._process_html_to_markdown(html_content, current_url)
+            if processed_markdown:
+                # Create a Document for each visited page
+                documents.append(
+                    Document(
+                        processed_markdown,  # content
+                        None,  # doc_id
+                        None,  # embedding
+                        {"source": current_url, "title": title, "language": language} # extra_info
+                    )
+                )
+
+            # Extract links and filter them according to domain rules
+            new_links = self._extract_links(html_content, current_url)
+            filtered_links = self._filter_links(new_links, base_domain)
+
+            # Add any new, not-yet-visited links to the queue
+            urls_to_visit.update(link for link in filtered_links if link not in visited_urls)
+
+            # If we've reached the limit, stop crawling
+            if self.limit is not None and len(visited_urls) >= self.limit:
+                break
+
+        return documents
+
+    def _fetch_page(self, url):
+        try:
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+            return response.text
+        except requests.exceptions.RequestException as e:
+            print(f"Error fetching URL {url}: {e}")
+            return None
+
+    def _process_html_to_markdown(self, html_content, current_url):
+        soup = BeautifulSoup(html_content, 'html.parser')
+        title_tag = soup.find('title')
+        title = title_tag.text.strip() if title_tag else "No Title"
+
+        # Extract language
+        language_tag = soup.find('html')
+        language = language_tag.get('lang', 'en') if language_tag else "en"
+
+        markdownified = markdownify(html_content, heading_style="ATX", newline_style="BACKSLASH")
+        # Reduce sequences of more than two newlines to exactly three
+        markdownified = re.sub(r'\n{3,}', '\n\n\n', markdownified)
+        return title, language, markdownified
+
+    def _extract_links(self, html_content, current_url):
+        soup = BeautifulSoup(html_content, 'html.parser')
+        links = []
+        for a in soup.find_all('a', href=True):
+            full_url = urljoin(current_url, a['href'])
+            links.append((full_url, a.text.strip()))
+        return links
+
+    def _get_base_domain(self, url):
+        extracted = tldextract.extract(url)
+        # Reconstruct the domain as domain.suffix
+        base_domain = f"{extracted.domain}.{extracted.suffix}"
+        return base_domain
+
+    def _filter_links(self, links, base_domain):
+        """
+        Filter the extracted links to only include those that match the crawling criteria:
+        - If allow_subdomains is True, allow any link whose domain ends with the base_domain.
+        - If allow_subdomains is False, only allow exact matches of the base_domain.
+        """
+        filtered = []
+        for link, _ in links:
+            parsed_link = urlparse(link)
+            if not parsed_link.netloc:
+                continue
+
+            extracted = tldextract.extract(parsed_link.netloc)
+            link_base = f"{extracted.domain}.{extracted.suffix}"
+
+            if self.allow_subdomains:
+                # For subdomains: sub.example.com ends with example.com
+                if link_base == base_domain or link_base.endswith("." + base_domain):
+                    filtered.append(link)
+            else:
+                # Exact domain match
+                if link_base == base_domain:
+                    filtered.append(link)
+        return filtered

application/parser/remote/web_loader.py

@@ -1,5 +1,7 @@
 from application.parser.remote.base import BaseRemote
+from application.parser.schema.base import Document
 from langchain_community.document_loaders import WebBaseLoader
+from urllib.parse import urlparse
 
 headers = {
     "User-Agent": "Mozilla/5.0",
@@ -23,10 +25,20 @@ class WebLoader(BaseRemote):
             urls = [urls]
         documents = []
         for url in urls:
+            # Check if the URL scheme is provided, if not, assume http
+            if not urlparse(url).scheme:
+                url = "http://" + url
             try:
                 loader = self.loader([url], header_template=headers)
-                documents.extend(loader.load())
+                loaded_docs = loader.load()
+                for doc in loaded_docs:
+                    documents.append(
+                        Document(
+                            doc.page_content,
+                            extra_info=doc.metadata,
+                        )
+                    )
             except Exception as e:
                 print(f"Error processing URL {url}: {e}")
                 continue
-        return documents
+        return documents

application/parser/token_func.py

@@ -1,79 +0,0 @@
-import re
-from math import ceil
-from typing import List
-
-import tiktoken
-from application.parser.schema.base import Document
-
-
-def separate_header_and_body(text):
-    header_pattern = r"^(.*?\n){3}"
-    match = re.match(header_pattern, text)
-    header = match.group(0)
-    body = text[len(header):]
-    return header, body
-
-
-def group_documents(documents: List[Document], min_tokens: int, max_tokens: int) -> List[Document]:
-    docs = []
-    current_group = None
-
-    for doc in documents:
-        doc_len = len(tiktoken.get_encoding("cl100k_base").encode(doc.text))
-
-        # Check if current group is empty or if the document can be added based on token count and matching metadata
-        if (current_group is None or 
-            (len(tiktoken.get_encoding("cl100k_base").encode(current_group.text)) + doc_len < max_tokens and 
-             doc_len < min_tokens and 
-             current_group.extra_info == doc.extra_info)):
-            if current_group is None:
-                current_group = doc  # Use the document directly to retain its metadata
-            else:
-                current_group.text += " " + doc.text  # Append text to the current group
-        else:
-            docs.append(current_group)
-            current_group = doc  # Start a new group with the current document
-
-    if current_group is not None:
-        docs.append(current_group)
-
-    return docs
-
-
-def split_documents(documents: List[Document], max_tokens: int) -> List[Document]:
-    docs = []
-    for doc in documents:
-        token_length = len(tiktoken.get_encoding("cl100k_base").encode(doc.text))
-        if token_length <= max_tokens:
-            docs.append(doc)
-        else:
-            header, body = separate_header_and_body(doc.text)
-            if len(tiktoken.get_encoding("cl100k_base").encode(header)) > max_tokens:
-                body = doc.text
-                header = ""
-            num_body_parts = ceil(token_length / max_tokens)
-            part_length = ceil(len(body) / num_body_parts)
-            body_parts = [body[i:i + part_length] for i in range(0, len(body), part_length)]
-            for i, body_part in enumerate(body_parts):
-                new_doc = Document(text=header + body_part.strip(),
-                                   doc_id=f"{doc.doc_id}-{i}",
-                                   embedding=doc.embedding,
-                                   extra_info=doc.extra_info)
-                docs.append(new_doc)
-    return docs
-
-
-def group_split(documents: List[Document], max_tokens: int = 2000, min_tokens: int = 150, token_check: bool = True):
-    if not token_check:
-        return documents
-    print("Grouping small documents")
-    try:
-        documents = group_documents(documents=documents, min_tokens=min_tokens, max_tokens=max_tokens)
-    except Exception:
-        print("Grouping failed, try running without token_check")
-    print("Separating large documents")
-    try:
-        documents = split_documents(documents=documents, max_tokens=max_tokens)
-    except Exception:
-        print("Grouping failed, try running without token_check")
-    return documents

application/requirements.txt

@@ -1,25 +1,28 @@
-anthropic==0.34.2
-boto3==1.34.153
+anthropic==0.49.0
+boto3==1.35.97
 beautifulsoup4==4.12.3
-celery==5.3.6
+celery==5.4.0
 dataclasses-json==0.6.7
 docx2txt==0.8
-duckduckgo-search==6.3.0
+duckduckgo-search==7.5.2
 ebooklib==0.18
-elastic-transport==8.15.0
-elasticsearch==8.15.1
+elastic-transport==8.17.0
+elasticsearch==8.17.1
 escodegen==1.0.11
 esprima==4.0.1
 esutils==1.0.1
-Flask==3.0.3
-faiss-cpu==1.8.0.post1
+Flask==3.1.0
+faiss-cpu==1.9.0.post1
 flask-restx==1.3.0
-gTTS==2.3.2
+gevent==24.11.1
+google-genai==1.3.0
+google-generativeai==0.8.3
+gTTS==2.5.4
 gunicorn==23.0.0
 html2text==2024.2.26
 javalang==0.13.0
-jinja2==3.1.4
-jiter==0.5.0
+jinja2==3.1.6
+jiter==0.8.2
 jmespath==1.0.1
 joblib==1.4.2
 jsonpatch==1.33
@@ -28,62 +31,67 @@ jsonschema==4.23.0
 jsonschema-spec==0.2.4
 jsonschema-specifications==2023.7.1
 kombu==5.4.2
-langchain==0.3.0
-langchain-community==0.3.0
-langchain-core==0.3.2
-langchain-openai==0.2.0
-langchain-text-splitters==0.3.0
-langsmith==0.1.125
+langchain==0.3.20
+langchain-community==0.3.19
+langchain-core==0.3.45
+langchain-openai==0.3.8
+langchain-text-splitters==0.3.6
+langsmith==0.3.15
 lazy-object-proxy==1.10.0
-lxml==5.3.0
-markupsafe==2.1.5
-marshmallow==3.22.0
+lxml==5.3.1
+markupsafe==3.0.2
+marshmallow==3.26.1
 mpmath==1.3.0
 multidict==6.1.0
 mypy-extensions==1.0.0
-networkx==3.3
-numpy==1.26.4
-openai==1.46.1
-openapi-schema-validator==0.6.2
+networkx==3.4.2
+numpy==2.2.1
+openai==1.66.3
+openapi-schema-validator==0.6.3
 openapi-spec-validator==0.6.0
-openapi3-parser==1.1.18
-orjson==3.10.7
+openapi3-parser==1.1.19
+orjson==3.10.14
 packaging==24.1
 pandas==2.2.3
 openpyxl==3.1.5
-pathable==0.4.3
-pillow==10.4.0
+pathable==0.4.4
+pillow==11.1.0
 portalocker==2.10.1
 prance==23.6.21.0
-primp==0.6.3
-prompt-toolkit==3.0.47
-protobuf==5.28.2
+primp==0.14.0
+prompt-toolkit==3.0.50
+protobuf==5.29.3
+psycopg2-binary==2.9.10
 py==1.11.0
-pydantic==2.9.2
-pydantic-core==2.23.4
-pydantic-settings==2.4.0
-pymongo==4.8.0
-pypdf2==3.0.1
+pydantic==2.10.6
+pydantic-core==2.27.2
+pydantic-settings==2.7.1
+pymongo==4.10.1
+pypdf==5.2.0
 python-dateutil==2.9.0.post0
 python-dotenv==1.0.1
+python-jose==3.4.0
 python-pptx==1.0.2
-qdrant-client==1.11.0
-redis==5.0.1
+qdrant-client==1.13.2
+redis==5.2.1
 referencing==0.30.2
-regex==2024.9.11
+regex==2024.11.6
 requests==2.32.3
 retry==0.9.2
-sentence-transformers==3.0.1
-tiktoken==0.7.0
-tokenizers==0.19.1
-torch==2.4.1
-tqdm==4.66.5
-transformers==4.44.2
+sentence-transformers==3.3.1
+tiktoken==0.8.0
+tokenizers==0.21.0
+torch==2.5.1
+tqdm==4.67.1
+transformers==4.49.0
 typing-extensions==4.12.2
 typing-inspect==0.9.0
 tzdata==2024.2
-urllib3==2.2.3
+urllib3==2.3.0
 vine==5.1.0
 wcwidth==0.2.13
-werkzeug==3.0.4
-yarl==1.11.1
+werkzeug==3.1.3
+yarl==1.18.3
+markdownify==0.14.1
+tldextract==5.1.3
+websockets==14.1

application/retriever/brave_search.py

@@ -1,16 +1,16 @@
 import json
-from application.retriever.base import BaseRetriever
+
+from langchain_community.tools import BraveSearch
+
 from application.core.settings import settings
 from application.llm.llm_creator import LLMCreator
-from application.utils import num_tokens_from_string
-from langchain_community.tools import BraveSearch
+from application.retriever.base import BaseRetriever
 
 
 class BraveRetSearch(BaseRetriever):
 
     def __init__(
         self,
-        question,
         source,
         chat_history,
         prompt,
@@ -18,8 +18,9 @@ class BraveRetSearch(BaseRetriever):
         token_limit=150,
         gpt_model="docsgpt",
         user_api_key=None,
+        decoded_token=None,
     ):
-        self.question = question
+        self.question = ""
         self.source = source
         self.chat_history = chat_history
         self.prompt = prompt
@@ -36,6 +37,7 @@ class BraveRetSearch(BaseRetriever):
             )
         )
         self.user_api_key = user_api_key
+        self.decoded_token = decoded_token
 
     def _get_data(self):
         if self.chunks == 0:
@@ -72,33 +74,29 @@ class BraveRetSearch(BaseRetriever):
         for doc in docs:
             yield {"source": doc}
 
-        if len(self.chat_history) > 1:
-            tokens_current_history = 0
-            # count tokens in history
+        if len(self.chat_history) > 0:
             for i in self.chat_history:
                 if "prompt" in i and "response" in i:
-                    tokens_batch = num_tokens_from_string(i["prompt"]) + num_tokens_from_string(
-                        i["response"]
+                    messages_combine.append({"role": "user", "content": i["prompt"]})
+                    messages_combine.append(
+                        {"role": "assistant", "content": i["response"]}
                     )
-                    if tokens_current_history + tokens_batch < self.token_limit:
-                        tokens_current_history += tokens_batch
-                        messages_combine.append(
-                            {"role": "user", "content": i["prompt"]}
-                        )
-                        messages_combine.append(
-                            {"role": "system", "content": i["response"]}
-                        )
         messages_combine.append({"role": "user", "content": self.question})
 
         llm = LLMCreator.create_llm(
-            settings.LLM_NAME, api_key=settings.API_KEY, user_api_key=self.user_api_key
+            settings.LLM_NAME,
+            api_key=settings.API_KEY,
+            user_api_key=self.user_api_key,
+            decoded_token=self.decoded_token,
         )
 
         completion = llm.gen_stream(model=self.gpt_model, messages=messages_combine)
         for line in completion:
             yield {"answer": str(line)}
 
-    def search(self):
+    def search(self, query: str = ""):
+        if query:
+            self.question = query
         return self._get_data()
 
     def get_params(self):
@@ -110,5 +108,5 @@ class BraveRetSearch(BaseRetriever):
             "chunks": self.chunks,
             "token_limit": self.token_limit,
             "gpt_model": self.gpt_model,
-            "user_api_key": self.user_api_key
+            "user_api_key": self.user_api_key,
         }

application/retriever/classic_rag.py

@@ -1,27 +1,26 @@
-from application.retriever.base import BaseRetriever
 from application.core.settings import settings
-from application.vectorstore.vector_creator import VectorCreator
 from application.llm.llm_creator import LLMCreator
+from application.retriever.base import BaseRetriever
 
-from application.utils import num_tokens_from_string
+from application.vectorstore.vector_creator import VectorCreator
 
 
 class ClassicRAG(BaseRetriever):
-
     def __init__(
         self,
-        question,
         source,
-        chat_history,
-        prompt,
+        chat_history=None,
+        prompt="",
         chunks=2,
         token_limit=150,
         gpt_model="docsgpt",
         user_api_key=None,
+        llm_name=settings.LLM_NAME,
+        api_key=settings.API_KEY,
+        decoded_token=None,
     ):
-        self.question = question
-        self.vectorstore = source['active_docs'] if 'active_docs' in source else None
-        self.chat_history = chat_history
+        self.original_question = ""
+        self.chat_history = chat_history if chat_history is not None else []
         self.prompt = prompt
         self.chunks = chunks
         self.gpt_model = gpt_model
@@ -36,6 +35,45 @@ class ClassicRAG(BaseRetriever):
             )
         )
         self.user_api_key = user_api_key
+        self.llm_name = llm_name
+        self.api_key = api_key
+        self.llm = LLMCreator.create_llm(
+            self.llm_name,
+            api_key=self.api_key,
+            user_api_key=self.user_api_key,
+            decoded_token=decoded_token,
+        )
+        self.question = self._rephrase_query()
+        self.vectorstore = source["active_docs"] if "active_docs" in source else None
+        self.decoded_token = decoded_token
+
+    def _rephrase_query(self):
+        if (
+            not self.original_question
+            or not self.chat_history
+            or self.chat_history == []
+        ):
+            return self.original_question
+
+        prompt = f"""Given the following conversation history:
+        {self.chat_history}
+
+        Rephrase the following user question to be a standalone search query 
+        that captures all relevant context from the conversation:
+        """
+
+        messages = [
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": self.original_question},
+        ]
+
+        try:
+            rephrased_query = self.llm.gen(model=self.gpt_model, messages=messages)
+            print(f"Rephrased query: {rephrased_query}")
+            return rephrased_query if rephrased_query else self.original_question
+        except Exception as e:
+            print(f"Error rephrasing query: {e}")
+            return self.original_question
 
     def _get_data(self):
         if self.chunks == 0:
@@ -62,52 +100,22 @@ class ClassicRAG(BaseRetriever):
 
         return docs
 
-    def gen(self):
-        docs = self._get_data()
+    def gen():
+        pass
 
-        # join all page_content together with a newline
-        docs_together = "\n".join([doc["text"] for doc in docs])
-        p_chat_combine = self.prompt.replace("{summaries}", docs_together)
-        messages_combine = [{"role": "system", "content": p_chat_combine}]
-        for doc in docs:
-            yield {"source": doc}
-
-        if len(self.chat_history) > 1:
-            tokens_current_history = 0
-            # count tokens in history
-            for i in self.chat_history:
-                if "prompt" in i and "response" in i:
-                    tokens_batch = num_tokens_from_string(i["prompt"]) + num_tokens_from_string(
-                        i["response"]
-                    )
-                    if tokens_current_history + tokens_batch < self.token_limit:
-                        tokens_current_history += tokens_batch
-                        messages_combine.append(
-                            {"role": "user", "content": i["prompt"]}
-                        )
-                        messages_combine.append(
-                            {"role": "system", "content": i["response"]}
-                        )
-        messages_combine.append({"role": "user", "content": self.question})
-
-        llm = LLMCreator.create_llm(
-            settings.LLM_NAME, api_key=settings.API_KEY, user_api_key=self.user_api_key
-        )
-        completion = llm.gen_stream(model=self.gpt_model, messages=messages_combine)
-        for line in completion:
-            yield {"answer": str(line)}
-
-    def search(self):
+    def search(self, query: str = ""):
+        if query:
+            self.original_question = query
+            self.question = self._rephrase_query()
         return self._get_data()
-    
+
     def get_params(self):
         return {
-            "question": self.question,
+            "question": self.original_question,
+            "rephrased_question": self.question,
             "source": self.vectorstore,
-            "chat_history": self.chat_history,
-            "prompt": self.prompt,
             "chunks": self.chunks,
             "token_limit": self.token_limit,
             "gpt_model": self.gpt_model,
-            "user_api_key": self.user_api_key
+            "user_api_key": self.user_api_key,
         }

application/retriever/duckduck_search.py

@@ -1,16 +1,15 @@
-from application.retriever.base import BaseRetriever
-from application.core.settings import settings
-from application.llm.llm_creator import LLMCreator
-from application.utils import num_tokens_from_string
 from langchain_community.tools import DuckDuckGoSearchResults
 from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
 
+from application.core.settings import settings
+from application.llm.llm_creator import LLMCreator
+from application.retriever.base import BaseRetriever
+
 
 class DuckDuckSearch(BaseRetriever):
 
     def __init__(
         self,
-        question,
         source,
         chat_history,
         prompt,
@@ -18,8 +17,9 @@ class DuckDuckSearch(BaseRetriever):
         token_limit=150,
         gpt_model="docsgpt",
         user_api_key=None,
+        decoded_token=None,
     ):
-        self.question = question
+        self.question = ""
         self.source = source
         self.chat_history = chat_history
         self.prompt = prompt
@@ -36,42 +36,26 @@ class DuckDuckSearch(BaseRetriever):
             )
         )
         self.user_api_key = user_api_key
-
-    def _parse_lang_string(self, input_string):
-        result = []
-        current_item = ""
-        inside_brackets = False
-        for char in input_string:
-            if char == "[":
-                inside_brackets = True
-            elif char == "]":
-                inside_brackets = False
-                result.append(current_item)
-                current_item = ""
-            elif inside_brackets:
-                current_item += char
-
-        if inside_brackets:
-            result.append(current_item)
-
-        return result
+        self.decoded_token = decoded_token
 
     def _get_data(self):
         if self.chunks == 0:
             docs = []
         else:
             wrapper = DuckDuckGoSearchAPIWrapper(max_results=self.chunks)
-            search = DuckDuckGoSearchResults(api_wrapper=wrapper)
+            search = DuckDuckGoSearchResults(api_wrapper=wrapper, output_format="list")
             results = search.run(self.question)
-            results = self._parse_lang_string(results)
 
             docs = []
             for i in results:
                 try:
-                    text = i.split("title:")[0]
-                    title = i.split("title:")[1].split("link:")[0]
-                    link = i.split("link:")[1]
-                    docs.append({"text": text, "title": title, "link": link})
+                    docs.append(
+                        {
+                            "text": i.get("snippet", "").strip(),
+                            "title": i.get("title", "").strip(),
+                            "link": i.get("link", "").strip(),
+                        }
+                    )
                 except IndexError:
                     pass
         if settings.LLM_NAME == "llama.cpp":
@@ -89,35 +73,31 @@ class DuckDuckSearch(BaseRetriever):
         for doc in docs:
             yield {"source": doc}
 
-        if len(self.chat_history) > 1:
-            tokens_current_history = 0
-            # count tokens in history
+        if len(self.chat_history) > 0:
             for i in self.chat_history:
                 if "prompt" in i and "response" in i:
-                    tokens_batch = num_tokens_from_string(i["prompt"]) + num_tokens_from_string(
-                        i["response"]
+                    messages_combine.append({"role": "user", "content": i["prompt"]})
+                    messages_combine.append(
+                        {"role": "assistant", "content": i["response"]}
                     )
-                    if tokens_current_history + tokens_batch < self.token_limit:
-                        tokens_current_history += tokens_batch
-                        messages_combine.append(
-                            {"role": "user", "content": i["prompt"]}
-                        )
-                        messages_combine.append(
-                            {"role": "system", "content": i["response"]}
-                        )
         messages_combine.append({"role": "user", "content": self.question})
 
         llm = LLMCreator.create_llm(
-            settings.LLM_NAME, api_key=settings.API_KEY, user_api_key=self.user_api_key
+            settings.LLM_NAME,
+            api_key=settings.API_KEY,
+            user_api_key=self.user_api_key,
+            decoded_token=self.decoded_token,
         )
 
         completion = llm.gen_stream(model=self.gpt_model, messages=messages_combine)
         for line in completion:
             yield {"answer": str(line)}
 
-    def search(self):
+    def search(self, query: str = ""):
+        if query:
+            self.question = query
         return self._get_data()
-    
+
     def get_params(self):
         return {
             "question": self.question,
@@ -127,5 +107,5 @@ class DuckDuckSearch(BaseRetriever):
             "chunks": self.chunks,
             "token_limit": self.token_limit,
             "gpt_model": self.gpt_model,
-            "user_api_key": self.user_api_key
+            "user_api_key": self.user_api_key,
         }

application/tts/elevenlabs.py

@@ -1,29 +1,84 @@
-from io import BytesIO
+import asyncio
+import websockets
+import json
 import base64
+from io import BytesIO
 from application.tts.base import BaseTTS
 
 
 class ElevenlabsTTS(BaseTTS):
-    def __init__(self):
-        from elevenlabs.client import ElevenLabs
-
-        self.client = ElevenLabs(
-            api_key="ELEVENLABS_API_KEY",
-            )
-    
+    def __init__(self):        
+        self.api_key = 'ELEVENLABS_API_KEY'# here you should put your api key
+        self.model = "eleven_flash_v2_5"
+        self.voice = "VOICE_ID" # this is the hash code for the voice not the name!
+        self.write_audio = 1
 
     def text_to_speech(self, text):
-        lang = "en"
-        audio = self.client.generate(
-            text=text,
-            model="eleven_multilingual_v2",
-            voice="Brian",
-        )
-        audio_data = BytesIO()
-        for chunk in audio:
-            audio_data.write(chunk)
-        audio_bytes = audio_data.getvalue()
+        asyncio.run(self._text_to_speech_websocket(text))
 
-        # Encode to base64
-        audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
-        return audio_base64, lang
+    async def _text_to_speech_websocket(self, text):
+        uri = f"wss://api.elevenlabs.io/v1/text-to-speech/{self.voice}/stream-input?model_id={self.model}"
+        websocket = await websockets.connect(uri)
+        payload = {
+            "text": " ",
+            "voice_settings": {
+                "stability": 0.5,
+                "similarity_boost": 0.8,
+            },
+            "xi_api_key": self.api_key,
+        }
+
+        await websocket.send(json.dumps(payload))
+        
+        async def listen():
+            while 1:
+                try:
+                    msg = await websocket.recv()
+                    data = json.loads(msg)
+
+                    if data.get("audio"):
+                        print("audio received")
+                        yield base64.b64decode(data["audio"])
+                    elif data.get("isFinal"):
+                        break
+                except websockets.exceptions.ConnectionClosed:
+                    print("websocket closed")
+                    break
+        listen_task =  asyncio.create_task(self.stream(listen()))
+        
+        await websocket.send(json.dumps({"text": text}))
+        # this is to signal the end of the text, either use this or flush
+        await websocket.send(json.dumps({"text": ""})) 
+
+        await listen_task
+    
+    async def stream(self, audio_stream):
+        if self.write_audio:
+            audio_bytes = BytesIO()
+            async for chunk in audio_stream:
+                if chunk:
+                    audio_bytes.write(chunk)
+            with open("output_audio.mp3", "wb") as f:
+                f.write(audio_bytes.getvalue())
+        
+        else:
+            async for chunk in audio_stream:
+                pass # depends on the streamer!
+
+
+def test_elevenlabs_websocket():
+    """
+    Tests the ElevenlabsTTS text_to_speech method with a sample prompt.
+    Prints out the base64-encoded result and writes it to 'output_audio.mp3'.
+    """
+    # Instantiate your TTS class
+    tts = ElevenlabsTTS()
+
+    # Call the method with some sample text
+    tts.text_to_speech("Hello from ElevenLabs WebSocket!")
+
+    print("Saved audio to output_audio.mp3.")
+
+
+if __name__ == "__main__":
+    test_elevenlabs_websocket()

application/usage.py

@@ -1,17 +1,23 @@
 import sys
 from datetime import datetime
+
 from application.core.mongo_db import MongoDB
-from application.utils import num_tokens_from_string
+from application.utils import num_tokens_from_object_or_list, num_tokens_from_string
 
 mongo = MongoDB.get_client()
 db = mongo["docsgpt"]
 usage_collection = db["token_usage"]
 
 
-def update_token_usage(user_api_key, token_usage):
+def update_token_usage(decoded_token, user_api_key, token_usage):
     if "pytest" in sys.modules:
         return
+    if decoded_token:
+        user_id = decoded_token["sub"]
+    else:
+        user_id = None
     usage_data = {
+        "user_id": user_id,
         "api_key": user_api_key,
         "prompt_tokens": token_usage["prompt_tokens"],
         "generated_tokens": token_usage["generated_tokens"],
@@ -21,28 +27,38 @@ def update_token_usage(user_api_key, token_usage):
 
 
 def gen_token_usage(func):
-    def wrapper(self, model, messages, stream, **kwargs):
+    def wrapper(self, model, messages, stream, tools, **kwargs):
         for message in messages:
-            self.token_usage["prompt_tokens"] += num_tokens_from_string(message["content"])
-        result = func(self, model, messages, stream, **kwargs)
-        self.token_usage["generated_tokens"] += num_tokens_from_string(result)
-        update_token_usage(self.user_api_key, self.token_usage)
+            if message["content"]:
+                self.token_usage["prompt_tokens"] += num_tokens_from_string(
+                    message["content"]
+                )
+        result = func(self, model, messages, stream, tools, **kwargs)
+        if isinstance(result, str):
+            self.token_usage["generated_tokens"] += num_tokens_from_string(result)
+        else:
+            self.token_usage["generated_tokens"] += num_tokens_from_object_or_list(
+                result
+            )
+        update_token_usage(self.decoded_token, self.user_api_key, self.token_usage)
         return result
 
     return wrapper
 
 
 def stream_token_usage(func):
-    def wrapper(self, model, messages, stream, **kwargs):
+    def wrapper(self, model, messages, stream, tools, **kwargs):
         for message in messages:
-            self.token_usage["prompt_tokens"] += num_tokens_from_string(message["content"])
+            self.token_usage["prompt_tokens"] += num_tokens_from_string(
+                message["content"]
+            )
         batch = []
-        result = func(self, model, messages, stream, **kwargs)
+        result = func(self, model, messages, stream, tools, **kwargs)
         for r in result:
             batch.append(r)
             yield r
         for line in batch:
             self.token_usage["generated_tokens"] += num_tokens_from_string(line)
-        update_token_usage(self.user_api_key, self.token_usage)
+        update_token_usage(self.decoded_token, self.user_api_key, self.token_usage)
 
     return wrapper

application/utils.py

@@ -1,5 +1,7 @@
-import tiktoken
 import hashlib
+import re
+
+import tiktoken
 from flask import jsonify, make_response
 
 
@@ -15,8 +17,22 @@ def get_encoding():
 
 def num_tokens_from_string(string: str) -> int:
     encoding = get_encoding()
-    num_tokens = len(encoding.encode(string))
-    return num_tokens
+    if isinstance(string, str):
+        num_tokens = len(encoding.encode(string))
+        return num_tokens
+    else:
+        return 0
+
+
+def num_tokens_from_object_or_list(thing):
+    if isinstance(thing, list):
+        return sum([num_tokens_from_object_or_list(x) for x in thing])
+    elif isinstance(thing, dict):
+        return sum([num_tokens_from_object_or_list(x) for x in thing.values()])
+    elif isinstance(thing, str):
+        return num_tokens_from_string(thing)
+    else:
+        return 0
 
 
 def count_tokens_docs(docs):
@@ -44,5 +60,52 @@ def check_required_fields(data, required_fields):
 
 
 def get_hash(data):
-    return hashlib.md5(data.encode()).hexdigest()
+    return hashlib.md5(data.encode(), usedforsecurity=False).hexdigest()
 
+
+def limit_chat_history(history, max_token_limit=None, gpt_model="docsgpt"):
+    """
+    Limits chat history based on token count.
+    Returns a list of messages that fit within the token limit.
+    """
+    from application.core.settings import settings
+
+    max_token_limit = (
+        max_token_limit
+        if max_token_limit
+        and max_token_limit
+        < settings.MODEL_TOKEN_LIMITS.get(gpt_model, settings.DEFAULT_MAX_HISTORY)
+        else settings.MODEL_TOKEN_LIMITS.get(gpt_model, settings.DEFAULT_MAX_HISTORY)
+    )
+
+    if not history:
+        return []
+
+    trimmed_history = []
+    tokens_current_history = 0
+
+    for message in reversed(history):
+        tokens_batch = 0
+        if "prompt" in message and "response" in message:
+            tokens_batch += num_tokens_from_string(message["prompt"])
+            tokens_batch += num_tokens_from_string(message["response"])
+
+        if "tool_calls" in message:
+            for tool_call in message["tool_calls"]:
+                tool_call_string = f"Tool: {tool_call.get('tool_name')} | Action: {tool_call.get('action_name')} | Args: {tool_call.get('arguments')} | Response: {tool_call.get('result')}"
+                tokens_batch += num_tokens_from_string(tool_call_string)
+
+        if tokens_current_history + tokens_batch < max_token_limit:
+            tokens_current_history += tokens_batch
+            trimmed_history.insert(0, message)
+        else:
+            break
+
+    return trimmed_history
+
+
+def validate_function_name(function_name):
+    """Validates if a function name matches the allowed pattern."""
+    if not re.match(r"^[a-zA-Z0-9_-]+$", function_name):
+        return False
+    return True

application/vectorstore/base.py

@@ -75,9 +75,9 @@ class BaseVectorStore(ABC):
                     openai_api_key=embeddings_key
                 )
         elif embeddings_name == "huggingface_sentence-transformers/all-mpnet-base-v2":
-            if os.path.exists("./model/all-mpnet-base-v2"):
+            if os.path.exists("./models/all-mpnet-base-v2"):
                 embedding_instance = EmbeddingsSingleton.get_instance(
-                    embeddings_name="./model/all-mpnet-base-v2",
+                    embeddings_name = "./models/all-mpnet-base-v2",
                 )
             else:
                 embedding_instance = EmbeddingsSingleton.get_instance(
@@ -86,4 +86,5 @@ class BaseVectorStore(ABC):
         else:
             embedding_instance = EmbeddingsSingleton.get_instance(embeddings_name)
 
-        return embedding_instance
+        return embedding_instance
+    

application/vectorstore/faiss.py

@@ -1,8 +1,12 @@
-from langchain_community.vectorstores import FAISS
-from application.vectorstore.base import BaseVectorStore
-from application.core.settings import settings
 import os
 
+from langchain_community.vectorstores import FAISS
+
+from application.core.settings import settings
+from application.parser.schema.base import Document
+from application.vectorstore.base import BaseVectorStore
+
+
 def get_vectorstore(path: str) -> str:
     if path:
         vectorstore = os.path.join("application", "indexes", path)
@@ -10,21 +14,25 @@ def get_vectorstore(path: str) -> str:
         vectorstore = os.path.join("application")
     return vectorstore
 
+
 class FaissStore(BaseVectorStore):
     def __init__(self, source_id: str, embeddings_key: str, docs_init=None):
         super().__init__()
+        self.source_id = source_id
         self.path = get_vectorstore(source_id)
-        embeddings = self._get_embeddings(settings.EMBEDDINGS_NAME, embeddings_key)
+        self.embeddings = self._get_embeddings(settings.EMBEDDINGS_NAME, embeddings_key)
 
         try:
             if docs_init:
-                self.docsearch = FAISS.from_documents(docs_init, embeddings)
+                self.docsearch = FAISS.from_documents(docs_init, self.embeddings)
             else:
-                self.docsearch = FAISS.load_local(self.path, embeddings, allow_dangerous_deserialization=True)
+                self.docsearch = FAISS.load_local(
+                    self.path, self.embeddings, allow_dangerous_deserialization=True
+                )
         except Exception:
             raise
 
-        self.assert_embedding_dimensions(embeddings)
+        self.assert_embedding_dimensions(self.embeddings)
 
     def search(self, *args, **kwargs):
         return self.docsearch.similarity_search(*args, **kwargs)
@@ -40,11 +48,42 @@ class FaissStore(BaseVectorStore):
 
     def assert_embedding_dimensions(self, embeddings):
         """Check that the word embedding dimension of the docsearch index matches the dimension of the word embeddings used."""
-        if settings.EMBEDDINGS_NAME == "huggingface_sentence-transformers/all-mpnet-base-v2":
-            word_embedding_dimension = getattr(embeddings, 'dimension', None)
+        if (
+            settings.EMBEDDINGS_NAME
+            == "huggingface_sentence-transformers/all-mpnet-base-v2"
+        ):
+            word_embedding_dimension = getattr(embeddings, "dimension", None)
             if word_embedding_dimension is None:
-                raise AttributeError("'dimension' attribute not found in embeddings instance.")
-            
+                raise AttributeError(
+                    "'dimension' attribute not found in embeddings instance."
+                )
+
             docsearch_index_dimension = self.docsearch.index.d
             if word_embedding_dimension != docsearch_index_dimension:
-                raise ValueError(f"Embedding dimension mismatch: embeddings.dimension ({word_embedding_dimension}) != docsearch index dimension ({docsearch_index_dimension})")
+                raise ValueError(
+                    f"Embedding dimension mismatch: embeddings.dimension ({word_embedding_dimension}) != docsearch index dimension ({docsearch_index_dimension})"
+                )
+
+    def get_chunks(self):
+        chunks = []
+        if self.docsearch:
+            for doc_id, doc in self.docsearch.docstore._dict.items():
+                chunk_data = {
+                    "doc_id": doc_id,
+                    "text": doc.page_content,
+                    "metadata": doc.metadata,
+                }
+                chunks.append(chunk_data)
+        return chunks
+
+    def add_chunk(self, text, metadata=None):
+        metadata = metadata or {}
+        doc = Document(text=text, extra_info=metadata).to_langchain_format()
+        doc_id = self.docsearch.add_documents([doc])
+        self.save_local(self.path)
+        return doc_id
+
+    def delete_chunk(self, chunk_id):
+        self.delete_index([chunk_id])
+        self.save_local(self.path)
+        return True

application/vectorstore/mongodb.py

@@ -124,3 +124,53 @@ class MongoDBVectorStore(BaseVectorStore):
 
     def delete_index(self, *args, **kwargs):
         self._collection.delete_many({"source_id": self._source_id})
+
+    def get_chunks(self):
+        try:
+            chunks = []
+            cursor = self._collection.find({"source_id": self._source_id})
+            for doc in cursor:
+                doc_id = str(doc.get("_id"))
+                text = doc.get(self._text_key)
+                metadata = {
+                    k: v
+                    for k, v in doc.items()
+                    if k
+                    not in ["_id", self._text_key, self._embedding_key, "source_id"]
+                }
+
+                if text:
+                    chunks.append(
+                        {"doc_id": doc_id, "text": text, "metadata": metadata}
+                    )
+
+            return chunks
+        except Exception as e:
+            print(f"Error getting chunks: {e}")
+            return []
+
+    def add_chunk(self, text, metadata=None):
+        metadata = metadata or {}
+        embeddings = self._embedding.embed_documents([text])
+        if not embeddings:
+            raise ValueError("Could not generate embedding for chunk")
+
+        chunk_data = {
+            self._text_key: text,
+            self._embedding_key: embeddings[0],
+            "source_id": self._source_id,
+            **metadata,
+        }
+        result = self._collection.insert_one(chunk_data)
+        return str(result.inserted_id)
+
+    def delete_chunk(self, chunk_id):
+        try:
+            from bson.objectid import ObjectId
+
+            object_id = ObjectId(chunk_id)
+            result = self._collection.delete_one({"_id": object_id})
+            return result.deleted_count > 0
+        except Exception as e:
+            print(f"Error deleting chunk: {e}")
+            return False

application/worker.py

@@ -12,10 +12,10 @@ from bson.objectid import ObjectId
 from application.core.mongo_db import MongoDB
 from application.core.settings import settings
 from application.parser.file.bulk import SimpleDirectoryReader
-from application.parser.open_ai_func import call_openai_api
+from application.parser.embedding_pipeline import embed_and_store_documents
 from application.parser.remote.remote_creator import RemoteCreator
 from application.parser.schema.base import Document
-from application.parser.token_func import group_split
+from application.parser.chunking import Chunker
 from application.utils import count_tokens_docs
 
 mongo = MongoDB.get_client()
@@ -126,7 +126,6 @@ def ingest_worker(
     limit = None
     exclude = True
     sample = False
-    token_check = True
     full_path = os.path.join(directory, user, name_job)
 
     logging.info(f"Ingest file: {full_path}", extra={"user": user, "job": name_job})
@@ -153,17 +152,19 @@ def ingest_worker(
         exclude_hidden=exclude,
         file_metadata=metadata_from_filename,
     ).load_data()
-    raw_docs = group_split(
-        documents=raw_docs,
-        min_tokens=MIN_TOKENS,
+
+    chunker = Chunker(
+        chunking_strategy="classic_chunk",
         max_tokens=MAX_TOKENS,
-        token_check=token_check,
+        min_tokens=MIN_TOKENS,
+        duplicate_headers=False
     )
+    raw_docs = chunker.chunk(documents=raw_docs)
 
     docs = [Document.to_langchain_format(raw_doc) for raw_doc in raw_docs]
     id = ObjectId()
 
-    call_openai_api(docs, full_path, id, self)
+    embed_and_store_documents(docs, full_path, id, self)
     tokens = count_tokens_docs(docs)
     self.update_state(state="PROGRESS", meta={"current": 100})
 
@@ -202,52 +203,61 @@ def remote_worker(
     sync_frequency="never",
     operation_mode="upload",
     doc_id=None,
-):
-    token_check = True
+):  
     full_path = os.path.join(directory, user, name_job)
-
     if not os.path.exists(full_path):
         os.makedirs(full_path)
+
     self.update_state(state="PROGRESS", meta={"current": 1})
-    logging.info(
-        f"Remote job: {full_path}",
-        extra={"user": user, "job": name_job, "source_data": source_data},
-    )
+    try:
+        logging.info("Initializing remote loader with type: %s", loader)
+        remote_loader = RemoteCreator.create_loader(loader)
+        raw_docs = remote_loader.load_data(source_data)
 
-    remote_loader = RemoteCreator.create_loader(loader)
-    raw_docs = remote_loader.load_data(source_data)
+        chunker = Chunker(
+            chunking_strategy="classic_chunk",
+            max_tokens=MAX_TOKENS,
+            min_tokens=MIN_TOKENS,
+            duplicate_headers=False
+        )
+        docs = chunker.chunk(documents=raw_docs)
+        docs = [Document.to_langchain_format(raw_doc) for raw_doc in raw_docs]
+        tokens = count_tokens_docs(docs)
+        logging.info("Total tokens calculated: %d", tokens)
 
-    docs = group_split(
-        documents=raw_docs,
-        min_tokens=MIN_TOKENS,
-        max_tokens=MAX_TOKENS,
-        token_check=token_check,
-    )
-    tokens = count_tokens_docs(docs)
-    if operation_mode == "upload":
-        id = ObjectId()
-        call_openai_api(docs, full_path, id, self)
-    elif operation_mode == "sync":
-        if not doc_id or not ObjectId.is_valid(doc_id):
-            raise ValueError("doc_id must be provided for sync operation.")
-        id = ObjectId(doc_id)
-        call_openai_api(docs, full_path, id, self)
-    self.update_state(state="PROGRESS", meta={"current": 100})
+        if operation_mode == "upload":
+            id = ObjectId()
+            embed_and_store_documents(docs, full_path, id, self)
+        elif operation_mode == "sync":
+            if not doc_id or not ObjectId.is_valid(doc_id):
+                logging.error("Invalid doc_id provided for sync operation: %s", doc_id)
+                raise ValueError("doc_id must be provided for sync operation.")
+            id = ObjectId(doc_id)
+            embed_and_store_documents(docs, full_path, id, self)
 
-    file_data = {
-        "name": name_job,
-        "user": user,
-        "tokens": tokens,
-        "retriever": retriever,
-        "id": str(id),
-        "type": loader,
-        "remote_data": source_data,
-        "sync_frequency": sync_frequency,
-    }
-    upload_index(full_path, file_data)
+        self.update_state(state="PROGRESS", meta={"current": 100})
 
-    shutil.rmtree(full_path)
+        file_data = {
+            "name": name_job,
+            "user": user,
+            "tokens": tokens,
+            "retriever": retriever,
+            "id": str(id),
+            "type": loader,
+            "remote_data": source_data,
+            "sync_frequency": sync_frequency,
+        }
+        upload_index(full_path, file_data)
 
+    except Exception as e:
+        logging.error("Error in remote_worker task: %s", str(e), exc_info=True)
+        raise
+
+    finally:
+        if os.path.exists(full_path):
+            shutil.rmtree(full_path)
+
+    logging.info("remote_worker task completed successfully")
     return {"urls": source_data, "name_job": name_job, "user": user, "limited": False}
 
 def sync(

deployment/docker-compose-azure.yaml

@@ -1,6 +1,6 @@
 services:
   frontend:
-    build: ./frontend
+    build: ../frontend
     environment:
       - VITE_API_HOST=http://localhost:7091
       - VITE_API_STREAMING=$VITE_API_STREAMING
@@ -10,7 +10,7 @@ services:
       - backend
 
   backend:
-    build: ./application
+    build: ../application
     environment:
       - API_KEY=$OPENAI_API_KEY
       - EMBEDDINGS_KEY=$OPENAI_API_KEY
@@ -25,15 +25,15 @@ services:
     ports:
       - "7091:7091"
     volumes:
-      - ./application/indexes:/app/application/indexes
-      - ./application/inputs:/app/application/inputs
-      - ./application/vectors:/app/application/vectors
+      - ../application/indexes:/app/application/indexes
+      - ../application/inputs:/app/application/inputs
+      - ../application/vectors:/app/application/vectors
     depends_on:
         - redis
         - mongo
 
   worker:
-    build: ./application
+    build: ../application
     command: celery -A application.app.celery worker -l INFO
     environment:
       - API_KEY=$OPENAI_API_KEY

deployment/docker-compose-dev.yaml

@@ -0,0 +1,18 @@
+services:
+
+  redis:
+    image: redis:6-alpine
+    ports:
+      - 6379:6379
+
+  mongo:
+    image: mongo:6
+    ports:
+      - 27017:27017
+    volumes:
+      - mongodb_data_container:/data/db
+
+
+
+volumes:
+  mongodb_data_container:

deployment/docker-compose-local.yaml

@@ -1,8 +1,8 @@
 services:
   frontend:
-    build: ./frontend
+    build: ../frontend
     volumes:
-    - ./frontend/src:/app/src
+    - ../frontend/src:/app/src
     environment:
       - VITE_API_HOST=http://localhost:7091
       - VITE_API_STREAMING=$VITE_API_STREAMING

deployment/docker-compose.yaml

@@ -1,8 +1,8 @@
 services:
   frontend:
-    build: ./frontend
+    build: ../frontend
     volumes:
-      - ./frontend/src:/app/src
+      - ../frontend/src:/app/src
     environment:
       - VITE_API_HOST=http://localhost:7091
       - VITE_API_STREAMING=$VITE_API_STREAMING
@@ -12,7 +12,7 @@ services:
       - backend
 
   backend:
-    build: ./application
+    build: ../application
     environment:
       - API_KEY=$API_KEY
       - EMBEDDINGS_KEY=$API_KEY
@@ -21,19 +21,21 @@ services:
       - CELERY_RESULT_BACKEND=redis://redis:6379/1
       - MONGO_URI=mongodb://mongo:27017/docsgpt
       - CACHE_REDIS_URL=redis://redis:6379/2
+      - OPENAI_BASE_URL=$OPENAI_BASE_URL
+      - MODEL_NAME=$MODEL_NAME
     ports:
       - "7091:7091"
     volumes:
-      - ./application/indexes:/app/application/indexes
-      - ./application/inputs:/app/application/inputs
-      - ./application/vectors:/app/application/vectors
+      - ../application/indexes:/app/application/indexes
+      - ../application/inputs:/app/application/inputs
+      - ../application/vectors:/app/application/vectors
     depends_on:
       - redis
       - mongo
 
   worker:
-    build: ./application
-    command: celery -A application.app.celery worker -l INFO -B
+    build: ../application
+    command: celery -A application.app.celery worker -l INFO --pool=gevent -B
     environment:
       - API_KEY=$API_KEY
       - EMBEDDINGS_KEY=$API_KEY

deployment/optional/docker-compose.optional.ollama-cpu.yaml

@@ -0,0 +1,11 @@
+version: "3.8"
+services:
+  ollama:
+    image: ollama/ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama_data:/root/.ollama
+
+volumes:
+  ollama_data:

deployment/optional/docker-compose.optional.ollama-gpu.yaml

@@ -0,0 +1,16 @@
+version: "3.8"
+services:
+  ollama:
+    image: ollama/ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama_data:/root/.ollama
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - capabilities: [gpu]
+
+volumes:
+  ollama_data:

docker-compose-mock.yaml

@@ -1,20 +0,0 @@
-services:
-  frontend:
-    build: ./frontend
-    environment:
-      - VITE_API_HOST=http://localhost:7091
-      - VITE_API_STREAMING=$VITE_API_STREAMING
-    ports:
-      - "5173:5173"
-    depends_on:
-      - mock-backend
-
-  mock-backend:
-    build: ./mock-backend
-    ports:
-      - "7091:7091"
-
-  redis:
-    image: redis:6-alpine
-    ports:
-      - 6379:6379

docs/components/DeploymentCards.jsx

@@ -0,0 +1,120 @@
+import Image from 'next/image';
+
+const iconMap = {
+    'Amazon Lightsail': '/lightsail.png',
+    'Railway': '/railway.png',
+    'Civo Compute Cloud': '/civo.png',
+    'DigitalOcean Droplet': '/digitalocean.png',
+    'Kamatera Cloud': '/kamatera.png',
+};
+
+
+export function DeploymentCards({ items }) {
+    return (
+        <>
+            <div className="deployment-cards">
+                {items.map(({ title, link, description }) => {
+                    const isExternal = link.startsWith('https://');
+                    const iconSrc = iconMap[title] || '/default-icon.png'; // Default icon if not found
+
+                    return (
+                        <div
+                            key={title}
+                            className={`card${isExternal ? ' external' : ''}`}
+                        >
+                            <a href={link} target={isExternal ? '_blank' : undefined} rel="noopener noreferrer" className="card-link-wrapper">
+                                <div className="card-icon-container">
+                                    {iconSrc && <div className="card-icon"><Image src={iconSrc} alt={title} width={32} height={32} /></div>} {/* Reduced icon size */}
+                                </div>
+                                <h3 className="card-title">{title}</h3>
+                                {description && <p className="card-description">{description}</p>}
+                                <p className="card-url">{new URL(link).hostname.replace('www.', '')}</p>
+                            </a>
+                        </div>
+                    );
+                })}
+            </div>
+
+            <style jsx>{`
+               .deployment-cards {
+                    margin-top: 24px;
+                    display: grid;
+                    grid-template-columns: 1fr;
+                    gap: 16px;
+                }
+                @media (min-width: 768px) {
+                    .deployment-cards {
+                        grid-template-columns: 1fr 1fr;
+                    }
+                }
+                .card {
+                    background-color: #222222;
+                    border-radius: 8px;
+                    padding: 16px;
+                    transition: background-color 0.3s;
+                    position: relative;
+                    color: #ffffff;
+                    /* Make the card a flex container */
+                    display: flex;
+                    flex-direction: column;
+                    align-items: center; /* Center horizontally */
+                    justify-content: center; /* Center vertically */
+                    height: 100%; /* Fill the height of the grid cell */
+                  
+                }
+                .card:hover {
+                    background-color: #333333;
+                }
+                .card.external::after {
+                    content: "↗";
+                    position: absolute;
+                    top: 12px; /* Adjusted position */
+                    right: 12px; /* Adjusted position */
+                    color: #ffffff;
+                    font-size: 0.7em; /* Reduced size */
+                    opacity: 0.8; /* Slightly faded */
+                }
+                .card-link-wrapper {
+                    display: flex;
+                    flex-direction: column;
+                    align-items:center;
+                    color: inherit;
+                    text-decoration: none;
+                    width:100%; /* Important: make link wrapper take full width */
+                }
+               .card-icon-container{
+                display:flex;
+                justify-content:center;
+                 width: 100%;
+                 margin-bottom: 8px; /* Space between icon and title */
+               }
+                .card-icon {
+                   display: block;
+                   margin: 0 auto;
+
+                }
+                .card-title {
+                    font-weight: 600;
+                    margin-bottom: 4px;
+                    font-size: 16px;
+                    text-align: center;
+                    color: #f0f0f0; /* Lighter title color if needed */
+                }
+                .card-description {
+                    margin-bottom: 0;
+                    font-size: 13px;
+                    color: #aaaaaa;
+                    text-align: center;
+                    line-height: 1.4;
+                }
+                .card-url {
+                    margin-top: 8px; /*Keep space consistent */
+                    font-size: 11px;
+                    color: #777777;
+                    text-align: center;
+                    font-family: monospace;
+                }
+            `}</style>
+        </>
+    );
+}

docs/package.json

@@ -7,8 +7,8 @@
   "license": "MIT",
   "dependencies": {
     "@vercel/analytics": "^1.1.1",
-    "docsgpt": "^0.4.7",
-    "next": "^14.2.12",
+    "docsgpt-react": "^0.5.0",
+    "next": "^14.2.26",
     "nextra": "^2.13.2",
     "nextra-theme-docs": "^2.13.2",
     "react": "^18.2.0",

docs/pages/API/API-docs.md

@@ -1,350 +0,0 @@
-# API Endpoints Documentation
-
-*Currently, the application provides the following main API endpoints:*
-
-
-### 1. /api/answer 
-**Description:**
-
-This endpoint is used to request answers to user-provided questions.
-
-**Request:**
-
-**Method**: `POST`
-
-**Headers**: Content-Type should be set to `application/json; charset=utf-8`
-
-**Request Body**: JSON object with the following fields:
-* `question` — The user's question.
-* `history`  —  (Optional) Previous conversation history.
-* `api_key`— Your API key.
-* `embeddings_key`  —  Your embeddings key.
-* `active_docs` — The location of active documentation.
-
-Here is a JavaScript Fetch Request example:
-```js
-// answer (POST http://127.0.0.1:5000/api/answer)
-fetch("http://127.0.0.1:5000/api/answer", {
-      "method": "POST",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-      "body": JSON.stringify({"question":"Hi","history":null,"api_key":"OPENAI_API_KEY","embeddings_key":"OPENAI_API_KEY",
-      "active_docs": "javascript/.project/ES2015/openai_text-embedding-ada-002/"})
-})
-.then((res) => res.text())
-.then(console.log.bind(console))
-```
-
-**Response**
-
-In response, you will get a JSON document containing the `answer`, `query` and `result`:
-```json
-{
-  "answer": "Hi there! How can I help you?\n",
-  "query": "Hi",
-  "result": "Hi there! How can I help you?\nSOURCES:"
-}
-```
-
-### 2. /api/docs_check
-
-**Description:**
-
-This endpoint will make sure documentation is loaded on the server (just run it every time user is switching between libraries (documentations)).
-
-**Request:**
-
-**Method**: `POST`
-
-**Headers**: Content-Type should be set to `application/json; charset=utf-8`
-
-**Request Body**: JSON object with the field:
-* `docs` — The location of the documentation:
-```js
-// docs_check (POST http://127.0.0.1:5000/api/docs_check)
-fetch("http://127.0.0.1:5000/api/docs_check", {
-      "method": "POST",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-      "body": JSON.stringify({"docs":"javascript/.project/ES2015/openai_text-embedding-ada-002/"})
-})
-.then((res) => res.text())
-.then(console.log.bind(console))
-```
-
-**Response:**
-
-In response, you will get a JSON document like this one indicating whether the documentation exists or not:
-```json
-{
-  "status": "exists"
-}
-```
-
-
-### 3. /api/combine
-**Description:**
-
-This endpoint provides information about available vectors and their locations with a simple GET request.
-
-**Request:**
-
-**Method**: `GET`
-
-**Response:**
-
-Response will include:
-* `date`
-* `description`
-* `docLink`
-* `fullName`
-* `language`
-* `location` (local or docshub)
-* `model`
-* `name`
-* `version`
-
-Example of JSON in Docshub and local:
-
-<img width="295" alt="image" src="https://user-images.githubusercontent.com/15183589/224714085-f09f51a4-7a9a-4efb-bd39-798029bb4273.png">
-
-### 4. /api/upload
-**Description:**
-
-This endpoint is used to upload a file that needs to be trained, response is JSON with task ID, which can be used to check on task's progress.
-
-**Request:**
-
-**Method**: `POST`
-
-**Request Body**: A multipart/form-data form with file upload and additional fields, including `user` and `name`.
-
-HTML example:
-
-```html
-<form action="/api/upload" method="post" enctype="multipart/form-data" class="mt-2">
-    <input type="file" name="file" class="py-4" id="file-upload">
-    <input type="text" name="user" value="local" hidden>
-    <input type="text" name="name" placeholder="Name:">
-    
-    <button type="submit" class="py-2 px-4 text-white bg-purple-30 rounded-md hover:bg-purple-30 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-purple-30">
-        Upload
-    </button>
-</form>
-```
-
-**Response:**
-
-JSON response with a status and a task ID that can be used to check the task's progress.
-
-
-### 5. /api/task_status
-**Description:**
-
-This endpoint is used to get the status of a task (`task_id`) from `/api/upload`
-
-**Request:**
-
-**Method**: `GET`
-
-**Query Parameter**: `task_id` (task ID to check)
-
-**Sample JavaScript Fetch Request:**
-```js
-// Task status (Get http://127.0.0.1:5000/api/task_status)
-fetch("http://localhost:5001/api/task_status?task_id=YOUR_TASK_ID", {
-      "method": "GET",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-})
-.then((res) => res.text())
-.then(console.log.bind(console))
-```
-
-**Response:**
-
-There are two types of responses:
-
-1. While the task is still running, the 'current' value will show progress from 0 to 100.
-   ```json
-   {
-     "result": {
-       "current": 1
-     },
-     "status": "PROGRESS"
-   }
-   ```
-
-2. When task is completed:
-   ```json
-   {
-     "result": {
-       "directory": "temp",
-       "filename": "install.rst",
-       "formats": [
-         ".rst",
-         ".md",
-         ".pdf"
-       ],
-       "name_job": "somename",
-       "user": "local"
-     },
-     "status": "SUCCESS"
-   }
-   ```
-
-### 6. /api/delete_old
-**Description:**
-
-This endpoint is used to delete old Vector Stores.
-
-**Request:**
-
-**Method**: `GET`
-
-**Query Parameter**: `task_id`
-
-**Sample JavaScript Fetch Request:**
-```js
-// delete_old (GET http://127.0.0.1:5000/api/delete_old)
-fetch("http://localhost:5001/api/delete_old?task_id=YOUR_TASK_ID", {
-      "method": "GET",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-})
-.then((res) => res.text())
-.then(console.log.bind(console))
-
-```
-**Response:**
-
-JSON response indicating the status of the operation:
-
-```json
-{ "status": "ok" }
-```
-
-### 7. /api/get_api_keys
-**Description:**
-
-The endpoint retrieves a list of API keys for the user.
-
-**Request:**
-
-**Method**: `GET`
-
-**Sample JavaScript Fetch Request:**
-```js
-// get_api_keys (GET http://127.0.0.1:5000/api/get_api_keys)
-fetch("http://localhost:5001/api/get_api_keys", {
-      "method": "GET",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-})
-.then((res) => res.text())
-.then(console.log.bind(console))
-
-```
-**Response:**
-
-JSON response with a list of created API keys:
-
-```json
-[
-      {
-        "id": "string",
-        "name": "string",
-        "key": "string",
-        "source": "string"
-      },
-      ...
-    ]
-```
-
-### 8. /api/create_api_key
-
-**Description:**
-
-Create a new API key for the user.
-
-**Request:**
-
-**Method**: `POST`
-
-**Headers**: Content-Type should be set to `application/json; charset=utf-8`
-
-**Request Body**: JSON object with the following fields:
-* `name` — A name for the API key.
-* `source` — The source documents that will be used.
-* `prompt_id` — The prompt ID.
-* `chunks` — The number of chunks used to process an answer.
-
-Here is a JavaScript Fetch Request example:
-```js
-// create_api_key (POST http://127.0.0.1:5000/api/create_api_key)
-fetch("http://127.0.0.1:5000/api/create_api_key", {
-      "method": "POST",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-      "body": JSON.stringify({"name":"Example Key Name",
-          "source":"Example Source",
-          "prompt_id":"creative",
-          "chunks":"2"})
-})
-.then((res) => res.json())
-.then(console.log.bind(console))
-```
-
-**Response**
-
-In response, you will get a JSON document containing the `id` and `key`:
-```json
-{
-  "id": "string",
-  "key": "string"
-}
-```
-
-### 9. /api/delete_api_key
-
-**Description:**
-
-Delete an API key for the user.
-
-**Request:**
-
-**Method**: `POST`
-
-**Headers**: Content-Type should be set to `application/json; charset=utf-8`
-
-**Request Body**: JSON object with the field:
-* `id` — The unique identifier of the API key to be deleted.
-
-Here is a JavaScript Fetch Request example:
-```js
-// delete_api_key (POST http://127.0.0.1:5000/api/delete_api_key)
-fetch("http://127.0.0.1:5000/api/delete_api_key", {
-      "method": "POST",
-      "headers": {
-            "Content-Type": "application/json; charset=utf-8"
-      },
-      "body": JSON.stringify({"id":"API_KEY_ID"})
-})
-.then((res) => res.json())
-.then(console.log.bind(console))
-```
-
-**Response:**
-
-In response, you will get a JSON document indicating the status of the operation:
-```json
-{
-  "status": "ok"
-}
-```

docs/pages/API/_meta.json

@@ -1,10 +0,0 @@
-{
-  "API-docs": {
-    "title": "🗂️️ API-docs",
-    "href": "/API/API-docs"
-  },
-  "api-key-guide": {
-    "title": "🔐 API Keys guide",
-    "href": "/API/api-key-guide"
-  }
-}

docs/pages/Deploying/Amazon-Lightsail.mdx

@@ -1,3 +1,9 @@
+---
+title: Hosting DocsGPT on Amazon Lightsail
+description:
+display: hidden
+---
+
 # Self-hosting DocsGPT on Amazon Lightsail
 
 Here's a step-by-step guide on how to set up an Amazon Lightsail instance to host DocsGPT.
@@ -73,7 +79,7 @@ To save the file, press CTRL+X, then Y, and then ENTER.
 
 Next, set the correct IP for the Backend by opening the docker-compose.yml file:
 
-`nano docker-compose.yml`
+`nano deployment/docker-compose.yaml`
 
 And Change line 7 to: `VITE_API_HOST=http://localhost:7091`
 to this `VITE_API_HOST=http://<your instance public IP>:7091`
@@ -84,7 +90,7 @@ This will allow the frontend to connect to the backend.
 
 You're almost there! Now that all the necessary bits and pieces have been installed, it is time to run the application. To do so, use the following command:
 
-`sudo docker-compose up -d`
+`sudo docker compose -f deployment/docker-compose.yaml up -d`
 
 Launching it for the first time will take a few minutes to download all the necessary dependencies and build.
 
@@ -101,10 +107,4 @@ Repeat the process for port `7091`.
 
 #### Access your instance
 
-Your instance is now available at your Public IP Address on port 5173. Enjoy using DocsGPT!
-
-## Other Deployment Options
-
-- [Deploy DocsGPT on Civo Compute Cloud](https://dev.to/rutamhere/deploying-docsgpt-on-civo-compute-c)
-- [Deploy DocsGPT on DigitalOcean Droplet](https://dev.to/rutamhere/deploying-docsgpt-on-digitalocean-droplet-50ea)
-- [Deploy DocsGPT on Kamatera Performance Cloud](https://dev.to/rutamhere/deploying-docsgpt-on-kamatera-performance-cloud-1bj)
+Your instance is now available at your Public IP Address on port 5173. Enjoy using DocsGPT!

docs/pages/Deploying/Development-Environment.mdx

@@ -0,0 +1,163 @@
+---
+title: Setting Up a Development Environment
+description: Guide to setting up a development environment for DocsGPT, including backend and frontend setup.
+---
+
+# Setting Up a Development Environment
+
+This guide will walk you through setting up a development environment for DocsGPT. This setup allows you to modify and test the application's backend and frontend components.
+
+## 1. Spin Up MongoDB and Redis
+
+For development purposes, you can quickly start MongoDB and Redis containers, which are the primary database and caching systems used by DocsGPT. We provide a dedicated Docker Compose file, `docker-compose-dev.yaml`, located in the `deployment` directory, that includes only these essential services.
+
+You can find the `docker-compose-dev.yaml` file [here](https://github.com/arc53/DocsGPT/blob/main/deployment/docker-compose-dev.yaml).
+
+**Steps to start MongoDB and Redis:**
+
+1.  Navigate to the root directory of your DocsGPT repository in your terminal.
+
+2.  Run the following commands to build and start the containers defined in `docker-compose-dev.yaml`:
+
+    ```bash
+    docker compose -f deployment/docker-compose-dev.yaml build
+    docker compose -f deployment/docker-compose-dev.yaml up -d
+    ```
+
+    These commands will start MongoDB and Redis in detached mode, running in the background.
+
+## 2. Run the Backend
+
+To run the DocsGPT backend locally, you'll need to set up a Python environment and install the necessary dependencies.
+
+**Prerequisites:**
+
+*   **Python 3.12:** Ensure you have Python 3.12 installed on your system. You can check your Python version by running `python --version` or `python3 --version` in your terminal.
+
+**Steps to run the backend:**
+
+1.  **Configure Environment Variables:**
+
+    DocsGPT backend settings are configured using environment variables. You can set these either in a `.env` file or directly in the `settings.py` file. For a comprehensive overview of all settings, please refer to the [DocsGPT Settings Guide](/Deploying/DocsGPT-Settings).
+
+    *   **Option 1: Using a `.env` file (Recommended):**
+        *   If you haven't already, create a file named `.env` in the **root directory** of your DocsGPT project.
+        *   Modify the `.env` file to adjust settings as needed. You can find a comprehensive list of configurable options in [`application/core/settings.py`](application/core/settings.py).
+
+    *   **Option 2: Exporting Environment Variables:**
+        *   Alternatively, you can export environment variables directly in your terminal. However, using a `.env` file is generally more organized for development.
+
+2.  **Create a Python Virtual Environment (Optional but Recommended):**
+
+    Using a virtual environment isolates project dependencies and avoids conflicts with system-wide Python packages.
+
+    *   **macOS and Linux:**
+
+        ```bash
+        python -m venv venv
+        . venv/bin/activate
+        ```
+
+    *   **Windows:**
+
+        ```bash
+        python -m venv venv
+         venv/Scripts/activate
+        ```
+
+3.  **Download Embedding Model:**
+
+    The backend requires an embedding model. Download the `mpnet-base-v2` model and place it in the `model/` directory within the project root. You can use the following script:
+
+    ```bash
+    wget https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip
+    unzip mpnet-base-v2.zip -d model
+    rm mpnet-base-v2.zip
+    ```
+
+    Alternatively, you can manually download the zip file from [here](https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip), unzip it, and place the extracted folder in `model/`.
+
+4.  **Install Backend Dependencies:**
+
+    Navigate to the root of your DocsGPT repository and install the required Python packages:
+
+    ```bash
+    pip install -r application/requirements.txt
+    ```
+
+5.  **Run the Flask App:**
+
+    Start the Flask backend application:
+
+    ```bash
+    flask --app application/app.py run --host=0.0.0.0 --port=7091
+    ```
+
+    This command will launch the backend server, making it accessible on `http://localhost:7091`.
+
+6.  **Start the Celery Worker:**
+
+    Open a new terminal window (and activate your virtual environment if you used one). Start the Celery worker to handle background tasks:
+
+    ```bash
+    celery -A application.app.celery worker -l INFO
+    ```
+
+    This command will start the Celery worker, which processes tasks such as document parsing and vector embedding.
+
+**Running in Debugger (VSCode):**
+
+For easier debugging, you can launch the Flask app and Celery worker directly from VSCode's debugger.
+
+*   Press <kbd>Shift</kbd> + <kbd>Cmd</kbd> + <kbd>D</kbd> (macOS) or <kbd>Shift</kbd> + <kbd>Windows</kbd> + <kbd>D</kbd> (Windows) to open the Run and Debug view.
+*   You should see configurations named "Flask" and "Celery". Select the desired configuration and click the "Start Debugging" button (green play icon).
+
+## 3. Start the Frontend
+
+To run the DocsGPT frontend locally, you'll need Node.js and npm (Node Package Manager).
+
+**Prerequisites:**
+
+*   **Node.js version 16 or higher:** Ensure you have Node.js version 16 or greater installed. You can check your Node.js version by running `node -v` in your terminal. npm is usually bundled with Node.js.
+
+**Steps to start the frontend:**
+
+1.  **Navigate to the Frontend Directory:**
+
+    In your terminal, change the current directory to the `frontend` folder within your DocsGPT repository:
+
+    ```bash
+    cd frontend
+    ```
+
+2.  **Install Global Packages (If Needed):**
+
+    If you don't have `husky` and `vite` installed globally, you can install them:
+
+    ```bash
+    npm install husky -g
+    npm install vite -g
+    ```
+    You can skip this step if you already have these packages installed or prefer to use local installations (though global installation simplifies running the commands in this guide).
+
+3.  **Install Frontend Dependencies:**
+
+    Install the project's frontend dependencies using npm:
+
+    ```bash
+    npm install --include=dev
+    ```
+
+    This command reads the `package.json` file in the `frontend` directory and installs all listed dependencies, including development dependencies.
+
+4.  **Run the Frontend App:**
+
+    Start the frontend development server:
+
+    ```bash
+    npm run dev
+    ```
+
+    This command will start the Vite development server. The frontend application will typically be accessible at [http://localhost:5173/](http://localhost:5173/). The terminal will display the exact URL where the frontend is running.
+
+With both the backend and frontend running, you should now have a fully functional DocsGPT development environment. You can access the application in your browser at [http://localhost:5173/](http://localhost:5173/) and start developing!

docs/pages/Deploying/Docker-Deploying.mdx

@@ -0,0 +1,135 @@
+---
+title: Docker Deployment of DocsGPT
+description: Deploy DocsGPT using Docker and Docker Compose for easy setup and management.
+---
+
+# Docker Deployment of DocsGPT
+
+Docker is the recommended method for deploying DocsGPT, providing a consistent and isolated environment for the application to run. This guide will walk you through deploying DocsGPT using Docker and Docker Compose.
+
+## Prerequisites
+
+* **Docker Engine:** You need to have Docker Engine installed on your system.
+    * **macOS:** [Docker Desktop for Mac](https://docs.docker.com/desktop/install/mac-install/)
+    * **Linux:** [Docker Engine Installation Guide](https://docs.docker.com/engine/install/) (follow instructions for your specific distribution)
+    * **Windows:** [Docker Desktop for Windows](https://docs.docker.com/desktop/install/windows-install/) (requires WSL 2 backend, see notes below)
+* **Docker Compose:** Docker Compose is usually included with Docker Desktop. If you are using Docker Engine separately, ensure you have Docker Compose V2 installed.
+
+**Important Note for Windows Users:** Docker Desktop on Windows generally requires the WSL 2 backend to function correctly, especially when using features like host networking which are utilized in DocsGPT's Docker Compose setup. Ensure WSL 2 is enabled and configured in Docker Desktop settings.
+
+## Quickest Setup: Using DocsGPT Public API
+
+The fastest way to try out DocsGPT is by using the public API endpoint. This requires minimal configuration and no local LLM setup.
+
+1.  **Clone the DocsGPT Repository (if you haven't already):**
+
+    ```bash
+    git clone https://github.com/arc53/DocsGPT.git
+    cd DocsGPT
+    ```
+
+2.  **Create a `.env` file:**
+
+    In the root directory of your DocsGPT repository, create a file named `.env`.
+
+3.  **Add Public API Configuration to `.env`:**
+
+    Open the `.env` file and add the following lines:
+
+    ```
+    LLM_NAME=docsgpt
+    VITE_API_STREAMING=true
+    ```
+
+    This minimal configuration tells DocsGPT to use the public API. For more advanced settings and other LLM options, refer to the [DocsGPT Settings Guide](/Deploying/DocsGPT-Settings).
+
+4.  **Launch DocsGPT with Docker Compose:**
+
+    Navigate to the root directory of the DocsGPT repository in your terminal and run:
+
+    ```bash
+    docker compose -f deployment/docker-compose.yaml up -d
+    ```
+
+    The `-d` flag runs Docker Compose in detached mode (in the background).
+
+5.  **Access DocsGPT in your browser:**
+
+    Once the containers are running, open your web browser and go to [http://localhost:5173/](http://localhost:5173/).
+
+6.  **Stopping DocsGPT:**
+
+    To stop the application, navigate to the same directory in your terminal and run:
+
+    ```bash
+    docker compose -f deployment/docker-compose.yaml down
+    ```
+
+## Optional Ollama Setup (Local Models)
+
+DocsGPT provides optional Docker Compose files to easily integrate with [Ollama](https://ollama.com/) for running local models. These files add an official Ollama container to your Docker Compose setup. These files are located in the `deployment/optional/` directory.
+
+There are two Ollama optional files:
+
+*   **`docker-compose.optional.ollama-cpu.yaml`**: For running Ollama on CPU.
+*   **`docker-compose.optional.ollama-gpu.yaml`**: For running Ollama on GPU (requires Docker to be configured for GPU usage).
+
+### Launching with Ollama and Pulling a Model
+
+1.  **Clone the DocsGPT Repository and Create `.env` (as described above).**
+
+2.  **Launch DocsGPT with Ollama Docker Compose:**
+
+    Choose the appropriate Ollama Compose file (CPU or GPU) and launch DocsGPT:
+
+    **CPU:**
+    ```bash
+    docker compose --env-file .env -f deployment/docker-compose.yaml -f deployment/optional/docker-compose.optional.ollama-cpu.yaml up -d
+    ```
+    **GPU:**
+    ```bash
+    docker compose --env-file .env -f deployment/docker-compose.yaml -f deployment/optional/docker-compose.optional.ollama-gpu.yaml up -d
+    ```
+
+3.  **Pull the Ollama Model:**
+
+    **Crucially, after launching with Ollama, you need to pull the desired model into the Ollama container.**  Find the `MODEL_NAME` you configured in your `.env` file (e.g., `llama3.2:1b`). Then execute the following command to pull the model *inside* the running Ollama container:
+
+    ```bash
+    docker compose -f deployment/docker-compose.yaml -f deployment/optional/docker-compose.optional.ollama-cpu.yaml exec -it ollama ollama pull <MODEL_NAME>
+    ```
+    or (for GPU):
+     ```bash
+    docker compose -f deployment/docker-compose.yaml -f deployment/optional/docker-compose.optional.ollama-gpu.yaml exec -it ollama ollama pull <MODEL_NAME>
+    ```
+    Replace `<MODEL_NAME>` with the actual model name from your `.env` file.
+
+4.  **Access DocsGPT in your browser:**
+
+    Once the model is pulled and containers are running, open your web browser and go to [http://localhost:5173/](http://localhost:5173/).
+
+5.  **Stopping Ollama Setup:**
+
+    To stop a DocsGPT setup launched with Ollama optional files, use `docker compose down` and include all the compose files used during the `up` command:
+
+    ```bash
+    docker compose -f deployment/docker-compose.yaml -f deployment/optional/docker-compose.optional.ollama-cpu.yaml down
+    ```
+    or
+
+    ```bash
+    docker compose -f deployment/docker-compose.yaml -f deployment/optional/docker-compose.optional.ollama-gpu.yaml down
+    ```
+
+**Important for GPU Usage:**
+
+*   **NVIDIA Container Toolkit (for NVIDIA GPUs):** If you are using NVIDIA GPUs, you need to have the [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) installed and configured on your system for Docker to access your GPU.
+*   **Docker GPU Configuration:** Ensure Docker is configured to utilize your GPU. Refer to the [Ollama Docker Hub page](https://hub.docker.com/r/ollama/ollama) and Docker documentation for GPU setup instructions specific to your GPU type (NVIDIA, AMD, Intel).
+
+## Restarting After Configuration Changes
+
+Whenever you modify the `.env` file or any Docker Compose files, you need to restart the Docker containers for the changes to be applied.  Use the same `docker compose down` and `docker compose up -d` commands you used to launch DocsGPT, ensuring you include all relevant `-f` flags for optional files if you are using them.
+
+## Further Configuration
+
+This guide covers the basic Docker deployment of DocsGPT. For detailed information on configuring various aspects of DocsGPT, such as LLM providers, models, vector stores, and more, please refer to the comprehensive [DocsGPT Settings Guide](/Deploying/DocsGPT-Settings).

docs/pages/Deploying/DocsGPT-Settings.mdx

@@ -0,0 +1,107 @@
+---
+title: DocsGPT Settings
+description: Configure your DocsGPT application by understanding the basic settings.
+---
+
+# DocsGPT Settings
+
+DocsGPT is highly configurable, allowing you to tailor it to your specific needs and preferences. You can control various aspects of the application, from choosing the Large Language Model (LLM) provider to selecting embedding models and vector stores.
+
+This document will guide you through the basic settings you can configure in DocsGPT. These settings determine how DocsGPT interacts with LLMs and processes your data.
+
+## Configuration Methods
+
+There are two primary ways to configure DocsGPT settings:
+
+### 1. Configuration via `.env` file (Recommended)
+
+The easiest and recommended way to configure basic settings is by using a `.env` file. This file should be located in the **root directory** of your DocsGPT project (the same directory where `setup.sh` is located).
+
+**Example `.env` file structure:**
+
+```
+LLM_NAME=openai
+API_KEY=YOUR_OPENAI_API_KEY
+MODEL_NAME=gpt-4o
+```
+
+### 2. Configuration via `settings.py` file (Advanced)
+
+For more advanced configurations or if you prefer to manage settings directly in code, you can modify the `settings.py` file. This file is located in the `application/core` directory of your DocsGPT project.
+
+While modifying `settings.py` offers more flexibility, it's generally recommended to use the `.env` file for basic settings and reserve `settings.py` for more complex adjustments or when you need to configure settings programmatically.
+
+**Location of `settings.py`:** `application/core/settings.py`
+
+## Basic Settings Explained
+
+Here are some of the most fundamental settings you'll likely want to configure:
+
+- **`LLM_NAME`**: This setting determines which Large Language Model (LLM) provider DocsGPT will use.  It tells DocsGPT which API to interact with.
+
+    - **Common values:**
+        - `docsgpt`:  Use the DocsGPT Public API Endpoint (simple and free, as offered in `setup.sh` option 1).
+        - `openai`: Use OpenAI's API (requires an API key).
+        - `google`: Use Google's Vertex AI or Gemini models.
+        - `anthropic`: Use Anthropic's Claude models.
+        - `groq`: Use Groq's models.
+        - `huggingface`: Use HuggingFace Inference API.
+        - `azure_openai`: Use Azure OpenAI Service.
+        - `openai` (when using local inference engines like Ollama, Llama.cpp, TGI, etc.):  This signals DocsGPT to use an OpenAI-compatible API format, even if the actual LLM is running locally.
+
+- **`MODEL_NAME`**:  Specifies the specific model to use from the chosen LLM provider. The available models depend on the `LLM_NAME` you've selected.
+
+    - **Examples:**
+        - For `LLM_NAME=openai`: `gpt-4o`
+        - For `LLM_NAME=google`: `gemini-2.0-flash`
+        - For local models (e.g., Ollama): `llama3.2:1b` (or any model name available in your setup).
+
+- **`EMBEDDINGS_NAME`**:  This setting defines which embedding model DocsGPT will use to generate vector embeddings for your documents. Embeddings are numerical representations of text that allow DocsGPT to understand the semantic meaning of your documents for efficient search and retrieval.
+
+    - **Default value:** `huggingface_sentence-transformers/all-mpnet-base-v2` (a good general-purpose embedding model).
+    - **Other options:** You can explore other embedding models from Hugging Face Sentence Transformers or other providers if needed.
+
+- **`API_KEY`**:  Required for most cloud-based LLM providers.  This is your authentication key to access the LLM provider's API. You'll need to obtain this key from your chosen provider's platform.
+
+- **`OPENAI_BASE_URL`**:  Specifically used when `LLM_NAME` is set to `openai` but you are connecting to a local inference engine (like Ollama, Llama.cpp, etc.) that exposes an OpenAI-compatible API.  This setting tells DocsGPT where to find your local LLM server.
+
+## Configuration Examples
+
+Let's look at some concrete examples of how to configure these settings in your `.env` file.
+
+### Example for Cloud API Provider (OpenAI)
+
+To use OpenAI's `gpt-4o` model, you would configure your `.env` file like this:
+
+```
+LLM_NAME=openai
+API_KEY=YOUR_OPENAI_API_KEY  # Replace with your actual OpenAI API key
+MODEL_NAME=gpt-4o
+```
+
+Make sure to replace `YOUR_OPENAI_API_KEY` with your actual OpenAI API key.
+
+### Example for Local Deployment
+
+To use a local Ollama server with the `llama3.2:1b` model, you would configure your `.env` file like this:
+
+```
+LLM_NAME=openai # Using OpenAI compatible API format for local models
+API_KEY=None      # API Key is not needed for local Ollama
+MODEL_NAME=llama3.2:1b
+OPENAI_BASE_URL=http://host.docker.internal:11434/v1 # Default Ollama API URL within Docker
+EMBEDDINGS_NAME=huggingface_sentence-transformers/all-mpnet-base-v2 # You can also run embeddings locally if needed
+```
+
+In this case, even though you are using Ollama locally, `LLM_NAME` is set to `openai` because Ollama (and many other local inference engines) are designed to be API-compatible with OpenAI.  `OPENAI_BASE_URL` points DocsGPT to the local Ollama server.
+
+## Exploring More Settings
+
+These are just the basic settings to get you started. The `settings.py` file contains many more advanced options that you can explore to further customize DocsGPT, such as:
+
+- Vector store configuration (`VECTOR_STORE`, Qdrant, Milvus, LanceDB settings)
+- Retriever settings (`RETRIEVERS_ENABLED`)
+- Cache settings (`CACHE_REDIS_URL`)
+- And many more!
+
+For a complete list of available settings and their descriptions, refer to the `settings.py` file in `application/core`. Remember to restart your Docker containers after making changes to your `.env` file or `settings.py` for the changes to take effect.

docs/pages/Deploying/Hosting-the-app.mdx

@@ -0,0 +1,33 @@
+import { DeploymentCards } from '../../components/DeploymentCards';
+
+# Deployment Guides
+
+<DeploymentCards
+  items={[
+    {
+      title: 'Amazon Lightsail',
+      link: 'https://docs.docsgpt.cloud/Deploying/Amazon-Lightsail',
+      description: 'Self-hosting DocsGPT on Amazon Lightsail'
+    },
+    {
+      title: 'Railway',
+      link: 'https://docs.docsgpt.cloud/Deploying/Railway',
+      description: 'Hosting DocsGPT on Railway'
+    },
+    {
+      title: 'Civo Compute Cloud',
+      link: 'https://dev.to/rutamhere/deploying-docsgpt-on-civo-compute-c',
+      description: 'Step-by-step guide for Civo deployment'
+    },
+    {
+      title: 'DigitalOcean Droplet', 
+      link: 'https://dev.to/rutamhere/deploying-docsgpt-on-digitalocean-droplet-50ea',
+      description: 'Guide for DigitalOcean deployment'
+    },
+    {
+      title: 'Kamatera Cloud',
+      link: 'https://dev.to/rutamhere/deploying-docsgpt-on-kamatera-performance-cloud-1bj',
+      description: 'Kamatera deployment tutorial'
+    }
+  ]}
+/>

docs/pages/Deploying/Kubernetes-Deploying.mdx

@@ -1,4 +1,10 @@
-# Self-hosting DocsGPT on Kubernetes
+---
+title: Deploying DocsGPT on Kubernetes
+description: Learn how to self-host DocsGPT on a Kubernetes cluster for scalable and robust deployments.
+---
+
+# Self-hosting DocsGPT
+ on Kubernetes
 
 This guide will walk you through deploying DocsGPT on Kubernetes.
 
@@ -11,7 +17,7 @@ Ensure you have the following installed before proceeding:
 
 ## Folder Structure
 
-The `k8s` folder contains the necessary deployment and service configuration files:
+The `deployment/k8s` folder contains the necessary deployment and service configuration files:
 
 - `deployments/`
 - `services/`
@@ -23,7 +29,7 @@ The `k8s` folder contains the necessary deployment and service configuration fil
 
    ```sh
    git clone https://github.com/arc53/DocsGPT.git
-   cd docsgpt/k8s
+   cd docsgpt/deployment/k8s
    ```
 
 2. **Configure Secrets (optional)**