parser functions change

token_func proposed change to chunking. open_ai_func proposed change to embedding_pipeline. Late chunking first  implementation requires further testing.

.devcontainer/Dockerfile

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

@@ -1,49 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-{
-	"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

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

@@ -1,32 +0,0 @@
-#!/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

.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# 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: "daily"
+      interval: "weekly"
   - package-ecosystem: "npm" # See documentation for possible values
     directory: "/frontend" # Location of package manifests
     schedule:
-      interval: "daily"
+      interval: "weekly"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "weekly"

.github/workflows/bandit.yaml

@@ -1,40 +0,0 @@
-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@v6
-        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,33 +5,20 @@ on:
     types: [published]
 
 jobs:
-  build:
+  deploy:
     if: github.repository == 'arc53/DocsGPT'
-    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 }}
+    runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU  # Only needed for emulation, not for native arm64 builds
-        if: matrix.platform == 'linux/arm64'
+      - 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
@@ -46,67 +33,15 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push platform-specific images
+      - name: Build and push Docker images to docker.io and ghcr.io
         uses: docker/build-push-action@v6
         with:
           file: './application/Dockerfile'
-          platforms: ${{ matrix.platform }}
+          platforms: linux/amd64
           context: ./application
           push: true
           tags: |
-            ${{ 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
+            ${{ 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
           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,33 +5,20 @@ on:
     types: [published]
 
 jobs:
-  build:
+  deploy:
     if: github.repository == 'arc53/DocsGPT'
-    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 }}
+    runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU # Only needed for emulation, not for native arm64 builds
-        if: matrix.platform == 'linux/arm64'
+      - 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
@@ -46,67 +33,16 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push platform-specific images
+      # Runs a single command using the runners shell
+      - name: Build and push Docker images to docker.io and ghcr.io
         uses: docker/build-push-action@v6
         with:
           file: './frontend/Dockerfile'
-          platforms: ${{ matrix.platform }}
+          platforms: linux/amd64, linux/arm64
           context: ./frontend
           push: true
           tags: |
-            ${{ 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
+            ${{ 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
           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 multi-arch DocsGPT Docker image
+name: Build and push DocsGPT Docker image for development
 
 on:
   workflow_dispatch:
@@ -7,36 +7,27 @@ on:
       - main
 
 jobs:
-  build:
+  deploy:
     if: github.repository == 'arc53/DocsGPT'
-    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 }}
+    runs-on: ubuntu-latest
     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:
@@ -44,57 +35,15 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push platform-specific images
+      - name: Build and push Docker images to docker.io and ghcr.io
         uses: docker/build-push-action@v6
         with:
           file: './application/Dockerfile'
-          platforms: ${{ matrix.platform }}
+          platforms: linux/amd64
           context: ./application
           push: true
           tags: |
-            ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop-${{ matrix.suffix }}
-            ghcr.io/${{ github.repository_owner }}/docsgpt:develop-${{ matrix.suffix }}
-          provenance: false
-          sbom: false
+            ${{ secrets.DOCKER_USERNAME }}/docsgpt:develop
+            ghcr.io/${{ github.repository_owner }}/docsgpt:develop
           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,33 +7,20 @@ on:
       - main
 
 jobs:
-  build:
+  deploy:
     if: github.repository == 'arc53/DocsGPT'
-    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 }}
+    runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up QEMU # Only needed for emulation, not for native arm64 builds
-        if: matrix.platform == 'linux/arm64'
+      - 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
@@ -48,57 +35,15 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push platform-specific images
+      - name: Build and push Docker images to docker.io and ghcr.io
         uses: docker/build-push-action@v6
         with:
           file: './frontend/Dockerfile'
-          platforms: ${{ matrix.platform }}
+          platforms: linux/amd64
           context: ./frontend
           push: true
           tags: |
-            ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop-${{ matrix.suffix }}
-            ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop-${{ matrix.suffix }}
-          provenance: false
-          sbom: false
+            ${{ secrets.DOCKER_USERNAME }}/docsgpt-fe:develop
+            ghcr.io/${{ github.repository_owner }}/docsgpt-fe:develop
           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,11 +6,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.12"]
+        python-version: ["3.11"]
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
@@ -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.12'
-        uses: codecov/codecov-action@v5
+        if: github.event_name == 'pull_request' && matrix.python-version == '3.11'
+        uses: codecov/codecov-action@v4
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 

.gitignore

@@ -113,7 +113,6 @@ venv.bak/
 # Spyder project settings
 .spyderproject
 .spyproject
-.jwt_secret_key
 
 # Rope project settings
 .ropeproject

.vscode/launch.json

@@ -11,44 +11,6 @@
       "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,7 +27,6 @@ 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:
 
@@ -35,40 +34,19 @@ Tech Stack Overview:
 
 - 🖥 Backend: Developed in Python 🐍
 
-### 🌐 Frontend Contributions (⚛️ React, Vite)
+### 🌐 If you are looking to contribute to frontend (⚛️React, Vite):
 
-*   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.
+- 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).
 
-### 🖥 Backend Contributions (🐍 Python)
+Please try to follow the guidelines.
 
-- Review our issues and contribute to [`/application`](https://github.com/arc53/DocsGPT/tree/main/application) 
+### 🖥 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).
 - 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

@@ -0,0 +1,41 @@
+# **🎉 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,11 +3,13 @@
 </h1>
 
 <p align="center">
-  <strong>Private AI for agents, assistants and enterprise search</strong>
+  <strong>Open-Source Documentation Assistant</strong>
 </p>
 
 <p align="left">
-  <strong><a href="https://www.docsgpt.cloud/">DocsGPT</a></strong> is an open-source AI platform for building intelligent agents and assistants. Features Agent Builder, deep research tools, document analysis (PDF, Office, web content), Multi-model support (choose your provider or run locally), and rich API connectivity for agents with actionable tools and integrations. Deploy anywhere with complete privacy control.
+  <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.
 </p>
 
 <div align="center">
@@ -15,130 +17,174 @@
   <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)
-- [x] ReACT agent (March 2025)
-- [x] Chatbots menu re-design to handle tools, agent types, and more (April 2025)
-- [x] New input box in the conversation menu (April 2025)
-- [x] Add triggerable actions / tools (webhook) (April 2025)
-- [x] Agent optimisations (May 2025)
-- [x] Filesystem sources update (July 2025)
-- [x] Json Responses (August 2025)
-- [ ] Sharepoint integration (August 2025)
-- [ ] MCP support (August 2025)
-- [ ] Add OAuth 2.0 authentication for tools and sources (August 2025)
-- [ ] Agent scheduling
-
-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.
 
-[Get a Demo :wave:](https://www.docsgpt.cloud/contact)⁠
+[Book a Meeting :wave:](https://cal.com/arc53/docsgpt-demo-b2b)⁠
 
-[Send Email :email:](mailto:support@docsgpt.cloud?subject=DocsGPT%20support%2Fsolutions)
+[Send Email :email:](mailto:contact@arc53.com?subject=DocsGPT%20support%2Fsolutions)
 
-## Join the Lighthouse Program 🌟
 
-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.
+<img src="https://github.com/user-attachments/assets/9a1f21de-7a15-4e42-9424-70d22ba5a913" alt="video-example-of-docs-gpt" width="1000" height="500">
 
-[Learn More & Apply →](https://docs.google.com/forms/d/1KAADiJinUJ8EMQyfTXUIGyFbqINNClNR3jBNWq7DgTE)
+## Roadmap
+
+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
 
-A more detailed [Quickstart](https://docs.docsgpt.cloud/quickstart) is available in our documentation
+On Mac OS or Linux, write:
 
-1. **Clone the repository:**
+`./setup.sh`
 
-   ```bash
-   git clone https://github.com/arc53/DocsGPT.git
-   cd DocsGPT
+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]
    ```
 
-**For macOS and Linux:**
+   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.
 
-2. **Run the setup script:**
+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/.
 
-   ```bash
-   ./setup.sh
-   ```
+To stop, just run `Ctrl + C`.
 
-**For Windows:**
+## Development Environments
 
-2. **Run the PowerShell setup script:**
+### Spin up Mongo and Redis
 
-   ```powershell
-   PowerShell -ExecutionPolicy Bypass -File .\setup.ps1
-   ```
+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).
 
-Either script will guide you through setting up DocsGPT. Four options available: using the public API, running locally, connecting to a local inference engine, or using a cloud API provider. Scripts will automatically configure your `.env` file and handle necessary downloads and installations based on your chosen option.
+Run
 
-**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
 ```
 
-(or use the specific `docker compose down` command shown after running the setup script).
+### Run the Backend
 
 > [!Note]
-> For development environment setup instructions, please refer to the [Development Environment Guide](https://docs.docsgpt.cloud/Deploying/Development-Environment).
+> 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`.
 
 ## 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.

application/Dockerfile

@@ -6,20 +6,21 @@ 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.12 python3.12-venv && \
+    apt-get install -y --no-install-recommends gcc wget unzip libc6-dev python3.11 python3.11-distutils python3.11-venv && \
     rm -rf /var/lib/apt/lists/* 
 
 # Verify Python installation and setup symlink
-RUN if [ -f /usr/bin/python3.12 ]; then \
-        ln -s /usr/bin/python3.12 /usr/bin/python; \
+RUN if [ -f /usr/bin/python3.11 ]; then \
+        ln -s /usr/bin/python3.11 /usr/bin/python; \
     else \
-        echo "Python 3.12 not found"; exit 1; \
+        echo "Python 3.11 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 models && \
+    unzip mpnet-base-v2.zip -d model && \
     rm mpnet-base-v2.zip
 
 # Install Rust
@@ -32,7 +33,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.12 -m venv /venv
+RUN python3.11 -m venv /venv
 
 # Activate virtual environment and install Python packages
 ENV PATH="/venv/bin:$PATH"
@@ -48,8 +49,9 @@ FROM ubuntu:24.04 as final
 RUN apt-get update && \
     apt-get install -y software-properties-common && \
     add-apt-repository ppa:deadsnakes/ppa && \
-    apt-get update && apt-get install -y --no-install-recommends python3.12 && \
-    ln -s /usr/bin/python3.12 /usr/bin/python && \
+# Install Python
+    apt-get update && apt-get install -y --no-install-recommends python3.11 && \
+    ln -s /usr/bin/python3.11 /usr/bin/python && \
     rm -rf /var/lib/apt/lists/*
 
 # Set working directory
@@ -61,8 +63,7 @@ RUN groupadd -r appuser && \
 
 # Copy the virtual environment and model from the builder stage
 COPY --from=builder /venv /venv
-
-COPY --from=builder /models /app/models
+COPY --from=builder /model /app/model
 
 # Copy your application code
 COPY . /app/application
@@ -84,4 +85,4 @@ EXPOSE 7091
 USER appuser
 
 # Start Gunicorn
-CMD ["gunicorn", "-w", "1", "--timeout", "120", "--bind", "0.0.0.0:7091", "--preload", "application.wsgi:app"]
+CMD ["gunicorn", "-w", "2", "--timeout", "120", "--bind", "0.0.0.0:7091", "application.wsgi:app"]

application/agents/agent_creator.py

@@ -1,16 +0,0 @@
-from application.agents.classic_agent import ClassicAgent
-from application.agents.react_agent import ReActAgent
-
-
-class AgentCreator:
-    agents = {
-        "classic": ClassicAgent,
-        "react": ReActAgent,
-    }
-
-    @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}")
-        return agent_class(*args, **kwargs)

application/agents/base.py

@@ -1,400 +0,0 @@
-import logging
-import uuid
-from abc import ABC, abstractmethod
-from typing import Dict, Generator, List, Optional
-
-from bson.objectid import ObjectId
-
-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.core.settings import settings
-from application.llm.handlers.handler_creator import LLMHandlerCreator
-from application.llm.llm_creator import LLMCreator
-from application.logging import build_stack_data, log_activity, LogContext
-from application.retriever.base import BaseRetriever
-
-logger = logging.getLogger(__name__)
-
-
-class BaseAgent(ABC):
-    def __init__(
-        self,
-        endpoint: str,
-        llm_name: str,
-        gpt_model: str,
-        api_key: str,
-        user_api_key: Optional[str] = None,
-        prompt: str = "",
-        chat_history: Optional[List[Dict]] = None,
-        decoded_token: Optional[Dict] = None,
-        attachments: Optional[List[Dict]] = None,
-        json_schema: Optional[Dict] = None,
-    ):
-        self.endpoint = endpoint
-        self.llm_name = llm_name
-        self.gpt_model = gpt_model
-        self.api_key = api_key
-        self.user_api_key = user_api_key
-        self.prompt = prompt
-        self.decoded_token = decoded_token or {}
-        self.user: str = decoded_token.get("sub")
-        self.tool_config: Dict = {}
-        self.tools: List[Dict] = []
-        self.tool_calls: List[Dict] = []
-        self.chat_history: List[Dict] = chat_history if chat_history is not None else []
-        self.llm = LLMCreator.create_llm(
-            llm_name,
-            api_key=api_key,
-            user_api_key=user_api_key,
-            decoded_token=decoded_token,
-        )
-        self.llm_handler = LLMHandlerCreator.create_handler(
-            llm_name if llm_name else "default"
-        )
-        self.attachments = attachments or []
-        self.json_schema = json_schema
-
-    @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)
-
-    @abstractmethod
-    def _gen_inner(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext
-    ) -> Generator[Dict, None, None]:
-        pass
-
-    def _get_tools(self, api_key: str = None) -> Dict[str, Dict]:
-        mongo = MongoDB.get_client()
-        db = mongo[settings.MONGO_DB_NAME]
-        agents_collection = db["agents"]
-        tools_collection = db["user_tools"]
-
-        agent_data = agents_collection.find_one({"key": api_key or self.user_api_key})
-        tool_ids = agent_data.get("tools", []) if agent_data else []
-
-        tools = (
-            tools_collection.find(
-                {"_id": {"$in": [ObjectId(tool_id) for tool_id in tool_ids]}}
-            )
-            if tool_ids
-            else []
-        )
-        tools = list(tools)
-        tools_by_id = {str(tool["_id"]): tool for tool in tools} if tools else {}
-
-        return tools_by_id
-
-    def _get_user_tools(self, user="local"):
-        mongo = MongoDB.get_client()
-        db = mongo[settings.MONGO_DB_NAME]
-        user_tools_collection = db["user_tools"]
-        user_tools = user_tools_collection.find({"user": user, "status": True})
-        user_tools = list(user_tools)
-
-        return {str(i): tool for i, tool in enumerate(user_tools)}
-
-    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)
-
-        call_id = getattr(call, "id", None) or str(uuid.uuid4())
-        
-        # Check if parsing failed
-        if tool_id is None or action_name is None:
-            error_message = f"Error: Failed to parse LLM tool call. Tool name: {getattr(call, 'name', 'unknown')}"
-            logger.error(error_message)
-            
-            tool_call_data = {
-                "tool_name": "unknown",
-                "call_id": call_id,
-                "action_name": getattr(call, 'name', 'unknown'),
-                "arguments": call_args or {},
-                "result": f"Failed to parse tool call. Invalid tool name format: {getattr(call, 'name', 'unknown')}",
-            }
-            yield {"type": "tool_call", "data": {**tool_call_data, "status": "error"}}
-            self.tool_calls.append(tool_call_data)
-            return "Failed to parse tool call.", call_id
-        
-        # Check if tool_id exists in available tools
-        if tool_id not in tools_dict:
-            error_message = f"Error: Tool ID '{tool_id}' extracted from LLM call not found in available tools_dict. Available IDs: {list(tools_dict.keys())}"
-            logger.error(error_message)
-            
-            # Return error result
-            tool_call_data = {
-                "tool_name": "unknown",
-                "call_id": call_id,
-                "action_name": f"{action_name}_{tool_id}",
-                "arguments": call_args,
-                "result": f"Tool with ID {tool_id} not found. Available tools: {list(tools_dict.keys())}",
-            }
-            yield {"type": "tool_call", "data": {**tool_call_data, "status": "error"}}
-            self.tool_calls.append(tool_call_data)
-            return f"Tool with ID {tool_id} not found.", call_id
-        
-        tool_call_data = {
-            "tool_name": tools_dict[tool_id]["name"],
-            "call_id": call_id,
-            "action_name": f"{action_name}_{tool_id}",
-            "arguments": call_args,
-        }
-        yield {"type": "tool_call", "data": {**tool_call_data, "status": "pending"}}
-
-        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,
-                }
-                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)
-        tool_call_data["result"] = (
-            f"{str(result)[:50]}..." if len(str(result)) > 50 else result
-        )
-
-        yield {"type": "tool_call", "data": {**tool_call_data, "status": "completed"}}
-        self.tool_calls.append(tool_call_data)
-
-        return result, call_id
-
-    def _get_truncated_tool_calls(self):
-        return [
-            {
-                **tool_call,
-                "result": (
-                    f"{str(tool_call['result'])[:50]}..."
-                    if len(str(tool_call["result"])) > 50
-                    else tool_call["result"]
-                ),
-                "status": "completed",
-            }
-            for tool_call in self.tool_calls
-        ]
-
-    def _build_messages(
-        self,
-        system_prompt: str,
-        query: str,
-        retrieved_data: List[Dict],
-    ) -> List[Dict]:
-        docs_together = "\n".join([doc["text"] for doc in retrieved_data])
-        p_chat_combine = system_prompt.replace("{summaries}", docs_together)
-        messages_combine = [{"role": "system", "content": p_chat_combine}]
-
-        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") or 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})
-        return messages_combine
-
-    def _retriever_search(
-        self,
-        retriever: BaseRetriever,
-        query: str,
-        log_context: Optional[LogContext] = None,
-    ) -> List[Dict]:
-        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: List[Dict], log_context: Optional[LogContext] = None):
-        gen_kwargs = {"model": self.gpt_model, "messages": messages}
-
-        if (
-            hasattr(self.llm, "_supports_tools")
-            and self.llm._supports_tools
-            and self.tools
-        ):
-            gen_kwargs["tools"] = self.tools
-
-        if (
-            self.json_schema
-            and hasattr(self.llm, "_supports_structured_output")
-            and self.llm._supports_structured_output()
-        ):
-            structured_format = self.llm.prepare_structured_output_format(
-                self.json_schema
-            )
-            if structured_format:
-                if self.llm_name == "openai":
-                    gen_kwargs["response_format"] = structured_format
-                elif self.llm_name == "google":
-                    gen_kwargs["response_schema"] = structured_format
-
-        resp = self.llm.gen_stream(**gen_kwargs)
-
-        if log_context:
-            data = build_stack_data(self.llm, exclude_attributes=["client"])
-            log_context.stacks.append({"component": "llm", "data": data})
-        return resp
-
-    def _llm_handler(
-        self,
-        resp,
-        tools_dict: Dict,
-        messages: List[Dict],
-        log_context: Optional[LogContext] = None,
-        attachments: Optional[List[Dict]] = None,
-    ):
-        resp = self.llm_handler.process_message_flow(
-            self, resp, tools_dict, messages, attachments, True
-        )
-        if log_context:
-            data = build_stack_data(self.llm_handler, exclude_attributes=["tool_calls"])
-            log_context.stacks.append({"component": "llm_handler", "data": data})
-        return resp
-
-    def _handle_response(self, response, tools_dict, messages, log_context):
-        is_structured_output = (
-            self.json_schema is not None
-            and hasattr(self.llm, "_supports_structured_output")
-            and self.llm._supports_structured_output()
-        )
-
-        if isinstance(response, str):
-            answer_data = {"answer": response}
-            if is_structured_output:
-                answer_data["structured"] = True
-                answer_data["schema"] = self.json_schema
-            yield answer_data
-            return
-        if hasattr(response, "message") and getattr(response.message, "content", None):
-            answer_data = {"answer": response.message.content}
-            if is_structured_output:
-                answer_data["structured"] = True
-                answer_data["schema"] = self.json_schema
-            yield answer_data
-            return
-        processed_response_gen = self._llm_handler(
-            response, tools_dict, messages, log_context, self.attachments
-        )
-
-        for event in processed_response_gen:
-            if isinstance(event, str):
-                answer_data = {"answer": event}
-                if is_structured_output:
-                    answer_data["structured"] = True
-                    answer_data["schema"] = self.json_schema
-                yield answer_data
-            elif hasattr(event, "message") and getattr(event.message, "content", None):
-                answer_data = {"answer": event.message.content}
-                if is_structured_output:
-                    answer_data["structured"] = True
-                    answer_data["schema"] = self.json_schema
-                yield answer_data
-            elif isinstance(event, dict) and "type" in event:
-                yield event

application/agents/classic_agent.py

@@ -1,53 +0,0 @@
-from typing import Dict, Generator
-from application.agents.base import BaseAgent
-from application.logging import LogContext
-from application.retriever.base import BaseRetriever
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ClassicAgent(BaseAgent):
-    """A simplified agent with clear execution flow.
-
-    Usage:
-    1. Processes a query through retrieval
-    2. Sets up available tools
-    3. Generates responses using LLM
-    4. Handles tool interactions if needed
-    5. Returns standardized outputs
-
-    Easy to extend by overriding specific steps.
-    """
-
-    def _gen_inner(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext
-    ) -> Generator[Dict, None, None]:
-        # Step 1: Retrieve relevant data
-        retrieved_data = self._retriever_search(retriever, query, log_context)
-
-        # Step 2: Prepare tools
-        tools_dict = (
-            self._get_user_tools(self.user)
-            if not self.user_api_key
-            else self._get_tools(self.user_api_key)
-        )
-        self._prepare_tools(tools_dict)
-
-        # Step 3: Build and process messages
-        messages = self._build_messages(self.prompt, query, retrieved_data)
-        llm_response = self._llm_gen(messages, log_context)
-
-        # Step 4: Handle the response
-        yield from self._handle_response(
-            llm_response, tools_dict, messages, log_context
-        )
-
-        # Step 5: Return metadata
-        yield {"sources": retrieved_data}
-        yield {"tool_calls": self._get_truncated_tool_calls()}
-
-        # Log tool calls for debugging
-        log_context.stacks.append(
-            {"component": "agent", "data": {"tool_calls": self.tool_calls.copy()}}
-        )

application/agents/react_agent.py

@@ -1,229 +0,0 @@
-import os
-from typing import Dict, Generator, List, Any
-import logging
-
-from application.agents.base import BaseAgent
-from application.logging import build_stack_data, LogContext
-from application.retriever.base import BaseRetriever
-
-logger = logging.getLogger(__name__)
-
-current_dir = os.path.dirname(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-)
-with open(
-    os.path.join(current_dir, "application/prompts", "react_planning_prompt.txt"), "r"
-) as f:
-    planning_prompt_template = f.read()
-with open(
-    os.path.join(current_dir, "application/prompts", "react_final_prompt.txt"),
-    "r",
-) as f:
-    final_prompt_template = f.read()
-    
-MAX_ITERATIONS_REASONING = 10
-
-class ReActAgent(BaseAgent):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.plan: str = ""
-        self.observations: List[str] = []
-
-    def _extract_content_from_llm_response(self, resp: Any) -> str:
-        """
-        Helper to extract string content from various LLM response types.
-        Handles strings, message objects (OpenAI-like), and streams.
-        Adapt stream handling for your specific LLM client if not OpenAI.
-        """
-        collected_content = []
-        if isinstance(resp, str):
-            collected_content.append(resp)
-        elif ( # OpenAI non-streaming or Anthropic non-streaming (older SDK style)
-            hasattr(resp, "message")
-            and hasattr(resp.message, "content")
-            and resp.message.content is not None
-        ):
-            collected_content.append(resp.message.content)
-        elif ( # OpenAI non-streaming (Pydantic model), Anthropic new SDK non-streaming
-            hasattr(resp, "choices") and resp.choices and
-            hasattr(resp.choices[0], "message") and
-            hasattr(resp.choices[0].message, "content") and
-            resp.choices[0].message.content is not None
-        ):
-            collected_content.append(resp.choices[0].message.content) # OpenAI
-        elif ( # Anthropic new SDK non-streaming content block
-             hasattr(resp, "content") and isinstance(resp.content, list) and resp.content and
-             hasattr(resp.content[0], "text")
-        ):
-            collected_content.append(resp.content[0].text) # Anthropic
-        else:
-            # Assume resp is a stream if not a recognized object
-            try:
-                for chunk in resp: # This will fail if resp is not iterable (e.g. a non-streaming response object)
-                    content_piece = ""
-                    # OpenAI-like stream
-                    if hasattr(chunk, 'choices') and len(chunk.choices) > 0 and \
-                       hasattr(chunk.choices[0], 'delta') and \
-                       hasattr(chunk.choices[0].delta, 'content') and \
-                       chunk.choices[0].delta.content is not None:
-                        content_piece = chunk.choices[0].delta.content
-                    # Anthropic-like stream (ContentBlockDelta)
-                    elif hasattr(chunk, 'type') and chunk.type == 'content_block_delta' and \
-                         hasattr(chunk, 'delta') and hasattr(chunk.delta, 'text'):
-                        content_piece = chunk.delta.text
-                    elif isinstance(chunk, str): # Simplest case: stream of strings
-                        content_piece = chunk
-
-                    if content_piece:
-                        collected_content.append(content_piece)
-            except TypeError: # If resp is not iterable (e.g. a final response object that wasn't caught above)
-                logger.debug(f"Response type {type(resp)} could not be iterated as a stream. It might be a non-streaming object not handled by specific checks.")
-            except Exception as e:
-                logger.error(f"Error processing potential stream chunk: {e}, chunk was: {getattr(chunk, '__dict__', chunk)}")
-
-
-        return "".join(collected_content)
-
-    def _gen_inner(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext
-    ) -> Generator[Dict, None, None]:
-        # Reset state for this generation call
-        self.plan = ""
-        self.observations = []
-        retrieved_data = self._retriever_search(retriever, query, log_context)
-
-        if self.user_api_key:
-            tools_dict = self._get_tools(self.user_api_key)
-        else:
-            tools_dict = self._get_user_tools(self.user)
-        self._prepare_tools(tools_dict)
-
-        docs_together = "\n".join([doc["text"] for doc in retrieved_data])
-        iterating_reasoning = 0
-        while iterating_reasoning < MAX_ITERATIONS_REASONING:
-            iterating_reasoning += 1
-            # 1. Create Plan
-            logger.info("ReActAgent: Creating plan...")
-            plan_stream = self._create_plan(query, docs_together, log_context)
-            current_plan_parts = []
-            yield {"thought": f"Reasoning... (iteration {iterating_reasoning})\n\n"}
-            for line_chunk in plan_stream:
-                current_plan_parts.append(line_chunk)
-                yield {"thought": line_chunk}
-            self.plan = "".join(current_plan_parts)
-            if self.plan:
-                self.observations.append(f"Plan: {self.plan} Iteration: {iterating_reasoning}")
-
-
-            max_obs_len = 20000
-            obs_str = "\n".join(self.observations)
-            if len(obs_str) > max_obs_len:
-                obs_str = obs_str[:max_obs_len] + "\n...[observations truncated]"
-            execution_prompt_str = (
-                (self.prompt or "")
-                + f"\n\nFollow this plan:\n{self.plan}"
-                + f"\n\nObservations:\n{obs_str}"
-                + f"\n\nIf there is enough data to complete user query '{query}', Respond with 'SATISFIED' only. Otherwise, continue. Dont Menstion 'SATISFIED' in your response if you are not ready. "
-            )
-            
-            messages = self._build_messages(execution_prompt_str, query, retrieved_data)
-
-            resp_from_llm_gen = self._llm_gen(messages, log_context)
-
-            initial_llm_thought_content = self._extract_content_from_llm_response(resp_from_llm_gen)
-            if initial_llm_thought_content:
-                self.observations.append(f"Initial thought/response: {initial_llm_thought_content}")
-            else:
-                logger.info("ReActAgent: Initial LLM response (before handler) had no textual content (might be only tool calls).")
-            resp_after_handler = self._llm_handler(resp_from_llm_gen, tools_dict, messages, log_context)
-            
-            for tool_call_info in self.tool_calls: # Iterate over self.tool_calls populated by _llm_handler
-                observation_string = (
-                    f"Executed Action: Tool '{tool_call_info.get('tool_name', 'N/A')}' "
-                    f"with arguments '{tool_call_info.get('arguments', '{}')}'. Result: '{str(tool_call_info.get('result', ''))[:200]}...'"
-                )
-                self.observations.append(observation_string)
-
-            content_after_handler = self._extract_content_from_llm_response(resp_after_handler)
-            if content_after_handler:
-                self.observations.append(f"Response after tool execution: {content_after_handler}")
-            else:
-                logger.info("ReActAgent: LLM response after handler had no textual content.")
-
-            if log_context:
-                log_context.stacks.append(
-                    {"component": "agent_tool_calls", "data": {"tool_calls": self.tool_calls.copy()}}
-                )
-
-            yield {"sources": retrieved_data}
-
-            display_tool_calls = []
-            for tc in self.tool_calls:
-                cleaned_tc = tc.copy()
-                if len(str(cleaned_tc.get("result", ""))) > 50:
-                    cleaned_tc["result"] = str(cleaned_tc["result"])[:50] + "..."
-                display_tool_calls.append(cleaned_tc)
-            if display_tool_calls:
-                yield {"tool_calls": display_tool_calls}
-            
-            if "SATISFIED" in content_after_handler:
-                logger.info("ReActAgent: LLM satisfied with the plan and data. Stopping reasoning.")
-                break
-
-        # 3. Create Final Answer based on all observations
-        final_answer_stream = self._create_final_answer(query, self.observations, log_context)
-        for answer_chunk in final_answer_stream:
-            yield {"answer": answer_chunk}
-        logger.info("ReActAgent: Finished generating final answer.")
-
-    def _create_plan(
-        self, query: str, docs_data: str, log_context: LogContext = None
-    ) -> Generator[str, None, None]:
-        plan_prompt_filled = planning_prompt_template.replace("{query}", query)
-        if "{summaries}" in plan_prompt_filled:
-            summaries = docs_data if docs_data else "No documents retrieved."
-            plan_prompt_filled = plan_prompt_filled.replace("{summaries}", summaries)
-        plan_prompt_filled = plan_prompt_filled.replace("{prompt}", self.prompt or "")
-        plan_prompt_filled = plan_prompt_filled.replace("{observations}", "\n".join(self.observations))
-
-        messages = [{"role": "user", "content": plan_prompt_filled}]
-
-        plan_stream_from_llm = self.llm.gen_stream(
-            model=self.gpt_model, messages=messages, tools=getattr(self, 'tools', None) # Use self.tools
-        )
-        if log_context:
-            data = build_stack_data(self.llm)
-            log_context.stacks.append({"component": "planning_llm", "data": data})
-
-        for chunk in plan_stream_from_llm:
-            content_piece = self._extract_content_from_llm_response(chunk)
-            if content_piece:
-                yield content_piece
-
-    def _create_final_answer(
-        self, query: str, observations: List[str], log_context: LogContext = None
-    ) -> Generator[str, None, None]:
-        observation_string = "\n".join(observations)
-        max_obs_len = 10000
-        if len(observation_string) > max_obs_len:
-            observation_string = observation_string[:max_obs_len] + "\n...[observations truncated]"
-            logger.warning("ReActAgent: Truncated observations for final answer prompt due to length.")
-
-        final_answer_prompt_filled = final_prompt_template.format(
-            query=query, observations=observation_string
-        )
-
-        messages = [{"role": "user", "content": final_answer_prompt_filled}]
-
-        # Final answer should synthesize, not call tools.
-        final_answer_stream_from_llm = self.llm.gen_stream(
-            model=self.gpt_model, messages=messages, tools=None
-        )
-        if log_context:
-            data = build_stack_data(self.llm)
-            log_context.stacks.append({"component": "final_answer_llm", "data": data})
-
-        for chunk in final_answer_stream_from_llm:
-            content_piece = self._extract_content_from_llm_response(chunk)
-            if content_piece:
-                yield content_piece

application/agents/tools/api_tool.py

@@ -1,72 +0,0 @@
-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):
-        if query_params:
-            url = f"{url}?{requests.compat.urlencode(query_params)}"
-        # if isinstance(body, dict):
-        #     body = json.dumps(body)
-        try:
-            print(f"Making API call: {method} {url} with body: {body}")
-            if body == "{}":
-                body = None
-            response = requests.request(method, url, headers=headers, data=body)
-            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

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

@@ -1,182 +0,0 @@
-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"
-
-        params = {
-            "q": query,
-            "country": country,
-            "search_lang": search_lang,
-            "count": min(count, 20),
-            "offset": min(offset, 9),
-            "safesearch": safesearch,
-        }
-
-        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
-        headers = {
-            "Accept": "application/json",
-            "Accept-Encoding": "gzip",
-            "X-Subscription-Token": self.token,
-        }
-
-        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"
-
-        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,
-        }
-
-        headers = {
-            "Accept": "application/json",
-            "Accept-Encoding": "gzip",
-            "X-Subscription-Token": self.token,
-        }
-
-        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)",
-                        },
-                        "search_lang": {
-                            "type": "string",
-                            "description": "The search language preference (default: en)",
-                        },
-                        "freshness": {
-                            "type": "string",
-                            "description": "Time filter for results (pd: last 24h, pw: last week, pm: last month, py: last year)",
-                        },
-                    },
-                    "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)",
-                        },
-                        "count": {
-                            "type": "integer",
-                            "description": "Number of results to return (max 100, default: 5)",
-                        },
-                    },
-                    "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

@@ -1,76 +0,0 @@
-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/duckduckgo.py

@@ -1,114 +0,0 @@
-from application.agents.tools.base import Tool
-from duckduckgo_search import DDGS
-
-
-class DuckDuckGoSearchTool(Tool):
-    """
-    DuckDuckGo Search
-    A tool for performing web and image searches using DuckDuckGo.
-    """
-
-    def __init__(self, config):
-        self.config = config
-
-    def execute_action(self, action_name, **kwargs):
-        actions = {
-            "ddg_web_search": self._web_search,
-            "ddg_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,
-        max_results=5,
-    ):
-        print(f"Performing DuckDuckGo web search for: {query}")
-
-        try:
-            results = DDGS().text(
-                query,
-                max_results=max_results,
-            )
-
-            return {
-                "status_code": 200,
-                "results": results,
-                "message": "Web search completed successfully.",
-            }
-        except Exception as e:
-            return {
-                "status_code": 500,
-                "message": f"Web search failed: {str(e)}",
-            }
-
-    def _image_search(
-        self,
-        query,
-        max_results=5,
-    ):
-        print(f"Performing DuckDuckGo image search for: {query}")
-
-        try:
-            results = DDGS().images(
-                keywords=query,
-                max_results=max_results,
-            )
-
-            return {
-                "status_code": 200,
-                "results": results,
-                "message": "Image search completed successfully.",
-            }
-        except Exception as e:
-            return {
-                "status_code": 500,
-                "message": f"Image search failed: {str(e)}",
-            }
-
-    def get_actions_metadata(self):
-        return [
-            {
-                "name": "ddg_web_search",
-                "description": "Perform a web search using DuckDuckGo.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "Search query",
-                        },
-                        "max_results": {
-                            "type": "integer",
-                            "description": "Number of results to return (default: 5)",
-                        },
-                    },
-                    "required": ["query"],
-                },
-            },
-            {
-                "name": "ddg_image_search",
-                "description": "Perform an image search using DuckDuckGo.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "Search query",
-                        },
-                        "max_results": {
-                            "type": "integer",
-                            "description": "Number of results to return (default: 5, max: 50)",
-                        },
-                    },
-                    "required": ["query"],
-                },
-            },
-        ]
-
-    def get_config_requirements(self):
-        return {}

application/agents/tools/ntfy.py

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

@@ -1,163 +0,0 @@
-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/read_webpage.py

@@ -1,83 +0,0 @@
-import requests
-from markdownify import markdownify
-from application.agents.tools.base import Tool
-from urllib.parse import urlparse
-
-class ReadWebpageTool(Tool):
-    """
-    Read Webpage (browser)
-    A tool to fetch the HTML content of a URL and convert it to Markdown.
-    """
-
-    def __init__(self, config=None):
-        """
-        Initializes the tool.
-        :param config: Optional configuration dictionary. Not used by this tool.
-        """
-        self.config = config
-
-    def execute_action(self, action_name: str, **kwargs) -> str:
-        """
-        Executes the specified action. For this tool, the only action is 'read_webpage'.
-
-        :param action_name: The name of the action to execute. Should be 'read_webpage'.
-        :param kwargs: Keyword arguments, must include 'url'.
-        :return: The Markdown content of the webpage or an error message.
-        """
-        if action_name != "read_webpage":
-            return f"Error: Unknown action '{action_name}'. This tool only supports 'read_webpage'."
-
-        url = kwargs.get("url")
-        if not url:
-            return "Error: URL parameter is missing."
-
-        # Ensure the URL has a scheme (if not, default to http)
-        parsed_url = urlparse(url)
-        if not parsed_url.scheme:
-            url = "http://" + url
-        
-        try:
-            response = requests.get(url, timeout=10, headers={'User-Agent': 'DocsGPT-Agent/1.0'})
-            response.raise_for_status()  # Raise an exception for HTTP errors (4xx or 5xx)
-            
-            html_content = response.text
-            #soup = BeautifulSoup(html_content, 'html.parser')
-            
-            
-            markdown_content = markdownify(html_content, heading_style="ATX", newline_style="BACKSLASH")
-            
-            return markdown_content
-
-        except requests.exceptions.RequestException as e:
-            return f"Error fetching URL {url}: {e}"
-        except Exception as e:
-            return f"Error processing URL {url}: {e}"
-
-    def get_actions_metadata(self):
-        """
-        Returns metadata for the actions supported by this tool.
-        """
-        return [
-            {
-                "name": "read_webpage",
-                "description": "Fetches the HTML content of a given URL and returns it as clean Markdown text. Input must be a valid URL.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "url": {
-                            "type": "string",
-                            "description": "The fully qualified URL of the webpage to read (e.g., 'https://www.example.com').",
-                        }
-                    },
-                    "required": ["url"],
-                    "additionalProperties": False,
-                },
-            }
-        ]
-
-    def get_config_requirements(self):
-        """
-        Returns a dictionary describing the configuration requirements for the tool.
-        This tool does not require any specific configuration.
-        """
-        return {}

application/agents/tools/telegram.py

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

@@ -1,61 +0,0 @@
-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):
-        try:
-            call_args = json.loads(call.arguments)
-            tool_parts = call.name.split("_")
-            
-            # If the tool name doesn't contain an underscore, it's likely a hallucinated tool
-            if len(tool_parts) < 2:
-                logger.warning(f"Invalid tool name format: {call.name}. Expected format: action_name_tool_id")
-                return None, None, None
-                
-            tool_id = tool_parts[-1]
-            action_name = "_".join(tool_parts[:-1])
-            
-            # Validate that tool_id looks like a numerical ID
-            if not tool_id.isdigit():
-                logger.warning(f"Tool ID '{tool_id}' is not numerical. This might be a hallucinated tool call.")
-                
-        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):
-        try:
-            call_args = call.arguments
-            tool_parts = call.name.split("_")
-            
-            # If the tool name doesn't contain an underscore, it's likely a hallucinated tool
-            if len(tool_parts) < 2:
-                logger.warning(f"Invalid tool name format: {call.name}. Expected format: action_name_tool_id")
-                return None, None, None
-                
-            tool_id = tool_parts[-1]
-            action_name = "_".join(tool_parts[:-1])
-            
-            # Validate that tool_id looks like a numerical ID
-            if not tool_id.isdigit():
-                logger.warning(f"Tool ID '{tool_id}' is not numerical. This might be a hallucinated tool call.")
-                
-        except (AttributeError, TypeError) as e:
-            logger.error(f"Error parsing Google LLM call: {e}")
-            return None, None, None
-        return tool_id, action_name, call_args

application/agents/tools/tool_manager.py

@@ -1,42 +0,0 @@
-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/__init__.py

@@ -1,7 +0,0 @@
-from flask_restx import Api
-
-api = Api(
-    version="1.0",
-    title="DocsGPT API",
-    description="API for DocsGPT",
-)

application/api/answer/__init__.py

@@ -1,19 +0,0 @@
-from flask import Blueprint
-
-from application.api import api
-from application.api.answer.routes.answer import AnswerResource
-from application.api.answer.routes.base import answer_ns
-from application.api.answer.routes.stream import StreamResource
-
-
-answer = Blueprint("answer", __name__)
-
-api.add_namespace(answer_ns)
-
-
-def init_answer_routes():
-    api.add_resource(StreamResource, "/stream")
-    api.add_resource(AnswerResource, "/api/answer")
-
-
-init_answer_routes()

application/api/answer/routes.py

@@ -0,0 +1,619 @@
+import asyncio
+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_restx import fields, Namespace, Resource
+
+
+from application.core.mongo_db import MongoDB
+from application.core.settings import settings
+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
+
+logger = logging.getLogger(__name__)
+
+mongo = MongoDB.get_client()
+db = mongo["docsgpt"]
+conversations_collection = db["conversations"]
+sources_collection = db["sources"]
+prompts_collection = db["prompts"]
+api_key_collection = db["api_keys"]
+user_logs_collection = db["user_logs"]
+
+answer = Blueprint("answer", __name__)
+answer_ns = Namespace("answer", description="Answer related operations", path="/")
+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"
+elif settings.LLM_NAME == "anthropic":
+    gpt_model = "claude-2"
+elif settings.LLM_NAME == "groq":
+    gpt_model = "llama3-8b-8192"
+
+if settings.MODEL_NAME:  # in case there is particular model name configured
+    gpt_model = settings.MODEL_NAME
+
+# load the prompts
+current_dir = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+)
+with open(os.path.join(current_dir, "prompts", "chat_combine_default.txt"), "r") as f:
+    chat_combine_template = f.read()
+
+with open(os.path.join(current_dir, "prompts", "chat_reduce_prompt.txt"), "r") as f:
+    chat_reduce_template = f.read()
+
+with open(os.path.join(current_dir, "prompts", "chat_combine_creative.txt"), "r") as f:
+    chat_combine_creative = f.read()
+
+with open(os.path.join(current_dir, "prompts", "chat_combine_strict.txt"), "r") as f:
+    chat_combine_strict = f.read()
+
+api_key_set = settings.API_KEY is not None
+embeddings_key_set = settings.EMBEDDINGS_KEY is not None
+
+
+async def async_generate(chain, question, chat_history):
+    result = await chain.arun({"question": question, "chat_history": chat_history})
+    return result
+
+
+def run_async_chain(chain, question, chat_history):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    result = {}
+    try:
+        answer = loop.run_until_complete(async_generate(chain, question, chat_history))
+    finally:
+        loop.close()
+    result["answer"] = answer
+    return result
+
+
+def get_data_from_api_key(api_key):
+    data = api_key_collection.find_one({"key": api_key})
+    # # Raise custom exception if the API key is not found
+    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"])
+        if "retriever" in source_doc:
+            data["retriever"] = source_doc["retriever"]
+    else:
+        data["source"] = {}
+    return data
+
+
+def get_retriever(source_id: str):
+    doc = sources_collection.find_one({"_id": ObjectId(source_id)})
+    if doc is None:
+        raise Exception("Source document does not exist", 404)
+    retriever_name = None if "retriever" not in doc else doc["retriever"]
+    return retriever_name
+
+
+def is_azure_configured():
+    return (
+        settings.OPENAI_API_BASE
+        and settings.OPENAI_API_VERSION
+        and settings.AZURE_DEPLOYMENT_NAME
+    )
+
+
+def save_conversation(conversation_id, question, response, source_log_docs, llm):
+    if conversation_id is not None and conversation_id != "None":
+        conversations_collection.update_one(
+            {"_id": ObjectId(conversation_id)},
+            {
+                "$push": {
+                    "queries": {
+                        "prompt": question,
+                        "response": response,
+                        "sources": source_log_docs,
+                    }
+                }
+            },
+        )
+
+    else:
+        # create new conversation
+        # generate summary
+        messages_summary = [
+            {
+                "role": "assistant",
+                "content": "Summarise following conversation in no more than 3 "
+                "words, respond ONLY with the summary, use the same "
+                "language as the system",
+            },
+            {
+                "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,
+            },
+        ]
+
+        completion = llm.gen(model=gpt_model, messages=messages_summary, max_tokens=30)
+        conversation_id = conversations_collection.insert_one(
+            {
+                "user": "local",
+                "date": datetime.datetime.utcnow(),
+                "name": completion,
+                "queries": [
+                    {
+                        "prompt": question,
+                        "response": response,
+                        "sources": source_log_docs,
+                    }
+                ],
+            }
+        ).inserted_id
+    return conversation_id
+
+
+def get_prompt(prompt_id):
+    if prompt_id == "default":
+        prompt = chat_combine_template
+    elif prompt_id == "creative":
+        prompt = chat_combine_creative
+    elif prompt_id == "strict":
+        prompt = chat_combine_strict
+    else:
+        prompt = prompts_collection.find_one({"_id": ObjectId(prompt_id)})["content"]
+    return prompt
+
+
+def complete_stream(
+    question, retriever, conversation_id, user_api_key, isNoneDoc=False
+):
+
+    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"
+        for line in answer:
+            if "answer" in line:
+                response_full += str(line["answer"])
+                data = json.dumps(line)
+                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
+        )
+        if user_api_key is None:
+            conversation_id = save_conversation(
+                conversation_id, question, response_full, source_log_docs, llm
+            )
+            # 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",
+                "api_key": user_api_key,
+                "question": question,
+                "response": response_full,
+                "sources": source_log_docs,
+                "retriever_params": retriever_params,
+                "timestamp": datetime.datetime.now(datetime.timezone.utc),
+            }
+        )
+        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()
+        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"
+        return
+
+
+@answer_ns.route("/stream")
+class Stream(Resource):
+    stream_model = api.model(
+        "StreamModel",
+        {
+            "question": fields.String(
+                required=True, description="Question to be asked"
+            ),
+            "history": fields.List(
+                fields.String, required=False, description="Chat history"
+            ),
+            "conversation_id": fields.String(
+                required=False, description="Conversation ID"
+            ),
+            "prompt_id": fields.String(
+                required=False, default="default", description="Prompt ID"
+            ),
+            "chunks": fields.Integer(
+                required=False, default=2, description="Number of chunks"
+            ),
+            "token_limit": fields.Integer(required=False, description="Token limit"),
+            "retriever": fields.String(required=False, description="Retriever type"),
+            "api_key": fields.String(required=False, description="API key"),
+            "active_docs": fields.String(
+                required=False, description="Active documents"
+            ),
+            "isNoneDoc": fields.Boolean(
+                required=False, description="Flag indicating if no document is used"
+            ),
+        },
+    )
+
+    @api.expect(stream_model)
+    @api.doc(description="Stream a response based on the question and retriever")
+    def post(self):
+        data = request.get_json()
+        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 = json.loads(history)
+            conversation_id = data.get("conversation_id")
+            prompt_id = data.get("prompt_id", "default")
+            
+
+            chunks = int(data.get("chunks", 2))
+            token_limit = data.get("token_limit", settings.DEFAULT_MAX_HISTORY)
+            retriever_name = data.get("retriever", "classic")
+
+            if "api_key" in data:
+                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")
+                source = {"active_docs": data_key.get("source")}
+                retriever_name = data_key.get("retriever", retriever_name)
+                user_api_key = data["api_key"]
+
+            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
+
+            else:
+                source = {}
+                user_api_key = None
+
+            current_app.logger.info(
+                f"/stream - request_data: {data}, source: {source}",
+                extra={"data": json.dumps({"request_data": data, "source": source})},
+            )
+
+            prompt = get_prompt(prompt_id)
+            if "isNoneDoc" in data and data["isNoneDoc"] is True:
+                chunks = 0
+            retriever = RetrieverCreator.create_retriever(
+                retriever_name,
+                question=question,
+                source=source,
+                chat_history=history,
+                prompt=prompt,
+                chunks=chunks,
+                token_limit=token_limit,
+                gpt_model=gpt_model,
+                user_api_key=user_api_key,
+            )
+
+            return Response(
+                complete_stream(
+                    question=question,
+                    retriever=retriever,
+                    conversation_id=conversation_id,
+                    user_api_key=user_api_key,
+                    isNoneDoc=data.get("isNoneDoc"),
+                ),
+                mimetype="text/event-stream",
+            )
+
+        except ValueError:
+            message = "Malformed request body"
+            print("\033[91merr", str(message), file=sys.stderr)
+            return Response(
+                error_stream_generate(message),
+                status=400,
+                mimetype="text/event-stream",
+            )
+        except Exception as e:
+            current_app.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),
+                status=status_code,
+                mimetype="text/event-stream",
+            )
+
+
+def error_stream_generate(err_response):
+    data = json.dumps({"type": "error", "error": err_response})
+    yield f"data: {data}\n\n"
+
+
+@answer_ns.route("/api/answer")
+class Answer(Resource):
+    answer_model = api.model(
+        "AnswerModel",
+        {
+            "question": fields.String(
+                required=True, description="The question to answer"
+            ),
+            "history": fields.List(
+                fields.String, required=False, description="Conversation history"
+            ),
+            "conversation_id": fields.String(
+                required=False, description="Conversation ID"
+            ),
+            "prompt_id": fields.String(
+                required=False, default="default", description="Prompt ID"
+            ),
+            "chunks": fields.Integer(
+                required=False, default=2, description="Number of chunks"
+            ),
+            "token_limit": fields.Integer(required=False, description="Token limit"),
+            "retriever": fields.String(required=False, description="Retriever type"),
+            "api_key": fields.String(required=False, description="API key"),
+            "active_docs": fields.String(
+                required=False, description="Active documents"
+            ),
+            "isNoneDoc": fields.Boolean(
+                required=False, description="Flag indicating if no document is used"
+            ),
+        },
+    )
+
+    @api.expect(answer_model)
+    @api.doc(description="Provide an answer based on the question and retriever")
+    def post(self):
+        data = request.get_json()
+        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", [])
+            conversation_id = data.get("conversation_id")
+            prompt_id = data.get("prompt_id", "default")
+            chunks = int(data.get("chunks", 2))
+            token_limit = data.get("token_limit", settings.DEFAULT_MAX_HISTORY)
+            retriever_name = data.get("retriever", "classic")
+
+            if "api_key" in data:
+                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")
+                source = {"active_docs": data_key.get("source")}
+                retriever_name = data_key.get("retriever", retriever_name)
+                user_api_key = data["api_key"]
+            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
+            else:
+                source = {}
+                user_api_key = None
+
+            prompt = get_prompt(prompt_id)
+
+            current_app.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=history,
+                prompt=prompt,
+                chunks=chunks,
+                token_limit=token_limit,
+                gpt_model=gpt_model,
+                user_api_key=user_api_key,
+            )
+
+            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"]
+
+            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
+            )
+
+            result = {"answer": response_full, "sources": source_log_docs}
+            result["conversation_id"] = str(
+                save_conversation(
+                    conversation_id, question, response_full, source_log_docs, llm
+                )
+            )
+            retriever_params = retriever.get_params()
+            user_logs_collection.insert_one(
+                {
+                    "action": "api_answer",
+                    "level": "info",
+                    "user": "local",
+                    "api_key": user_api_key,
+                    "question": question,
+                    "response": response_full,
+                    "sources": source_log_docs,
+                    "retriever_params": retriever_params,
+                    "timestamp": datetime.datetime.now(datetime.timezone.utc),
+                }
+            )
+
+        except Exception as e:
+            current_app.logger.error(
+                f"/api/answer - error: {str(e)} - traceback: {traceback.format_exc()}",
+                extra={"error": str(e), "traceback": traceback.format_exc()},
+            )
+            return bad_request(500, str(e))
+
+        return make_response(result, 200)
+
+
+@answer_ns.route("/api/search")
+class Search(Resource):
+    search_model = api.model(
+        "SearchModel",
+        {
+            "question": fields.String(
+                required=True, description="The question to search"
+            ),
+            "chunks": fields.Integer(
+                required=False, default=2, description="Number of chunks"
+            ),
+            "api_key": fields.String(
+                required=False, description="API key for authentication"
+            ),
+            "active_docs": fields.String(
+                required=False, description="Active documents for retrieval"
+            ),
+            "retriever": fields.String(required=False, description="Retriever type"),
+            "token_limit": fields.Integer(
+                required=False, description="Limit for tokens"
+            ),
+            "isNoneDoc": fields.Boolean(
+                required=False, description="Flag indicating if no document is used"
+            ),
+        },
+    )
+
+    @api.expect(search_model)
+    @api.doc(
+        description="Search for relevant documents based on the question and retriever"
+    )
+    def post(self):
+        data = request.get_json()
+        required_fields = ["question"]
+        missing_fields = check_required_fields(data, required_fields)
+        if missing_fields:
+            return missing_fields
+
+        try:
+            question = data["question"]
+            chunks = int(data.get("chunks", 2))
+            token_limit = data.get("token_limit", settings.DEFAULT_MAX_HISTORY)
+            retriever_name = data.get("retriever", "classic")
+
+            if "api_key" in data:
+                data_key = get_data_from_api_key(data["api_key"])
+                chunks = int(data_key.get("chunks", 2))
+                source = {"active_docs": data_key.get("source")}
+                user_api_key = data["api_key"]
+            elif "active_docs" in data:
+                source = {"active_docs": data["active_docs"]}
+                user_api_key = None
+            else:
+                source = {}
+                user_api_key = None
+
+            current_app.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",
+                chunks=chunks,
+                token_limit=token_limit,
+                gpt_model=gpt_model,
+                user_api_key=user_api_key,
+            )
+
+            docs = retriever.search()
+            retriever_params = retriever.get_params()
+
+            user_logs_collection.insert_one(
+                {
+                    "action": "api_search",
+                    "level": "info",
+                    "user": "local",
+                    "api_key": user_api_key,
+                    "question": question,
+                    "sources": docs,
+                    "retriever_params": retriever_params,
+                    "timestamp": datetime.datetime.now(datetime.timezone.utc),
+                }
+            )
+
+            if data.get("isNoneDoc"):
+                for doc in docs:
+                    doc["source"] = "None"
+
+        except Exception as e:
+            current_app.logger.error(
+                f"/api/search - error: {str(e)} - traceback: {traceback.format_exc()}",
+                extra={"error": str(e), "traceback": traceback.format_exc()},
+            )
+            return bad_request(500, str(e))
+
+        return make_response(docs, 200)

application/api/answer/routes/answer.py

@@ -1,122 +0,0 @@
-import logging
-import traceback
-
-from flask import make_response, request
-from flask_restx import fields, Resource
-
-from application.api import api
-
-from application.api.answer.routes.base import answer_ns, BaseAnswerResource
-
-from application.api.answer.services.stream_processor import StreamProcessor
-
-logger = logging.getLogger(__name__)
-
-
-@answer_ns.route("/api/answer")
-class AnswerResource(Resource, BaseAnswerResource):
-    def __init__(self, *args, **kwargs):
-        Resource.__init__(self, *args, **kwargs)
-        BaseAnswerResource.__init__(self)
-
-    answer_model = answer_ns.model(
-        "AnswerModel",
-        {
-            "question": fields.String(
-                required=True, description="Question to be asked"
-            ),
-            "history": fields.List(
-                fields.String,
-                required=False,
-                description="Conversation history (only for new conversations)",
-            ),
-            "conversation_id": fields.String(
-                required=False,
-                description="Existing conversation ID (loads history)",
-            ),
-            "prompt_id": fields.String(
-                required=False, default="default", description="Prompt ID"
-            ),
-            "chunks": fields.Integer(
-                required=False, default=2, description="Number of chunks"
-            ),
-            "token_limit": fields.Integer(required=False, description="Token limit"),
-            "retriever": fields.String(required=False, description="Retriever type"),
-            "api_key": fields.String(required=False, description="API key"),
-            "active_docs": fields.String(
-                required=False, description="Active documents"
-            ),
-            "isNoneDoc": fields.Boolean(
-                required=False, description="Flag indicating if no document is used"
-            ),
-            "save_conversation": fields.Boolean(
-                required=False,
-                default=True,
-                description="Whether to save the conversation",
-            ),
-        },
-    )
-
-    @api.expect(answer_model)
-    @api.doc(description="Provide a response based on the question and retriever")
-    def post(self):
-        data = request.get_json()
-        if error := self.validate_request(data):
-            return error
-        decoded_token = getattr(request, "decoded_token", None)
-        processor = StreamProcessor(data, decoded_token)
-        try:
-            processor.initialize()
-            if not processor.decoded_token:
-                return make_response({"error": "Unauthorized"}, 401)
-            agent = processor.create_agent()
-            retriever = processor.create_retriever()
-
-            stream = self.complete_stream(
-                question=data["question"],
-                agent=agent,
-                retriever=retriever,
-                conversation_id=processor.conversation_id,
-                user_api_key=processor.agent_config.get("user_api_key"),
-                decoded_token=processor.decoded_token,
-                isNoneDoc=data.get("isNoneDoc"),
-                index=None,
-                should_save_conversation=data.get("save_conversation", True),
-            )
-            stream_result = self.process_response_stream(stream)
-
-            if len(stream_result) == 7:
-                (
-                    conversation_id,
-                    response,
-                    sources,
-                    tool_calls,
-                    thought,
-                    error,
-                    structured_info,
-                ) = stream_result
-            else:
-                conversation_id, response, sources, tool_calls, thought, error = (
-                    stream_result
-                )
-                structured_info = None
-
-            if error:
-                return make_response({"error": error}, 400)
-            result = {
-                "conversation_id": conversation_id,
-                "answer": response,
-                "sources": sources,
-                "tool_calls": tool_calls,
-                "thought": thought,
-            }
-
-            if structured_info:
-                result.update(structured_info)
-        except Exception as e:
-            logger.error(
-                f"/api/answer - error: {str(e)} - traceback: {traceback.format_exc()}",
-                extra={"error": str(e), "traceback": traceback.format_exc()},
-            )
-            return make_response({"error": str(e)}, 500)
-        return make_response(result, 200)

application/api/answer/routes/base.py

@@ -1,263 +0,0 @@
-import datetime
-import json
-import logging
-from typing import Any, Dict, Generator, List, Optional
-
-from flask import Response
-from flask_restx import Namespace
-
-from application.api.answer.services.conversation_service import ConversationService
-
-from application.core.mongo_db import MongoDB
-from application.core.settings import settings
-from application.llm.llm_creator import LLMCreator
-from application.utils import check_required_fields, get_gpt_model
-
-logger = logging.getLogger(__name__)
-
-
-answer_ns = Namespace("answer", description="Answer related operations", path="/")
-
-
-class BaseAnswerResource:
-    """Shared base class for answer endpoints"""
-
-    def __init__(self):
-        mongo = MongoDB.get_client()
-        db = mongo[settings.MONGO_DB_NAME]
-        self.user_logs_collection = db["user_logs"]
-        self.gpt_model = get_gpt_model()
-        self.conversation_service = ConversationService()
-
-    def validate_request(
-        self, data: Dict[str, Any], require_conversation_id: bool = False
-    ) -> Optional[Response]:
-        """Common request validation"""
-        required_fields = ["question"]
-        if require_conversation_id:
-            required_fields.append("conversation_id")
-        if missing_fields := check_required_fields(data, required_fields):
-            return missing_fields
-        return None
-
-    def complete_stream(
-        self,
-        question: str,
-        agent: Any,
-        retriever: Any,
-        conversation_id: Optional[str],
-        user_api_key: Optional[str],
-        decoded_token: Dict[str, Any],
-        isNoneDoc: bool = False,
-        index: Optional[int] = None,
-        should_save_conversation: bool = True,
-        attachment_ids: Optional[List[str]] = None,
-        agent_id: Optional[str] = None,
-        is_shared_usage: bool = False,
-        shared_token: Optional[str] = None,
-    ) -> Generator[str, None, None]:
-        """
-        Generator function that streams the complete conversation response.
-
-        Args:
-            question: The user's question
-            agent: The agent instance
-            retriever: The retriever instance
-            conversation_id: Existing conversation ID
-            user_api_key: User's API key if any
-            decoded_token: Decoded JWT token
-            isNoneDoc: Flag for document-less responses
-            index: Index of message to update
-            should_save_conversation: Whether to persist the conversation
-            attachment_ids: List of attachment IDs
-            agent_id: ID of agent used
-            is_shared_usage: Flag for shared agent usage
-            shared_token: Token for shared agent
-
-        Yields:
-            Server-sent event strings
-        """
-        try:
-            response_full, thought, source_log_docs, tool_calls = "", "", [], []
-            is_structured = False
-            schema_info = None
-            structured_chunks = []
-
-            for line in agent.gen(query=question, retriever=retriever):
-                if "answer" in line:
-                    response_full += str(line["answer"])
-                    if line.get("structured"):
-                        is_structured = True
-                        schema_info = line.get("schema")
-                        structured_chunks.append(line["answer"])
-                    else:
-                        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 truncated_sources:
-                        data = json.dumps(
-                            {"type": "source", "source": truncated_sources}
-                        )
-                        yield f"data: {data}\n\n"
-                elif "tool_calls" in line:
-                    tool_calls = line["tool_calls"]
-                elif "thought" in line:
-                    thought += line["thought"]
-                    data = json.dumps({"type": "thought", "thought": line["thought"]})
-                    yield f"data: {data}\n\n"
-                elif "type" in line:
-                    data = json.dumps(line)
-                    yield f"data: {data}\n\n"
-
-            if is_structured and structured_chunks:
-                structured_data = {
-                    "type": "structured_answer",
-                    "answer": response_full,
-                    "structured": True,
-                    "schema": schema_info,
-                }
-                data = json.dumps(structured_data)
-                yield f"data: {data}\n\n"
-
-            if isNoneDoc:
-                for doc in source_log_docs:
-                    doc["source"] = "None"
-            llm = LLMCreator.create_llm(
-                settings.LLM_PROVIDER,
-                api_key=settings.API_KEY,
-                user_api_key=user_api_key,
-                decoded_token=decoded_token,
-            )
-
-            if should_save_conversation:
-                conversation_id = self.conversation_service.save_conversation(
-                    conversation_id,
-                    question,
-                    response_full,
-                    thought,
-                    source_log_docs,
-                    tool_calls,
-                    llm,
-                    self.gpt_model,
-                    decoded_token,
-                    index=index,
-                    api_key=user_api_key,
-                    agent_id=agent_id,
-                    is_shared_usage=is_shared_usage,
-                    shared_token=shared_token,
-                    attachment_ids=attachment_ids,
-                )
-            else:
-                conversation_id = None
-            id_data = {"type": "id", "id": str(conversation_id)}
-            data = json.dumps(id_data)
-            yield f"data: {data}\n\n"
-
-            retriever_params = retriever.get_params()
-            log_data = {
-                "action": "stream_answer",
-                "level": "info",
-                "user": decoded_token.get("sub"),
-                "api_key": user_api_key,
-                "question": question,
-                "response": response_full,
-                "sources": source_log_docs,
-                "retriever_params": retriever_params,
-                "attachments": attachment_ids,
-                "timestamp": datetime.datetime.now(datetime.timezone.utc),
-            }
-            if is_structured:
-                log_data["structured_output"] = True
-                if schema_info:
-                    log_data["schema"] = schema_info
-  
-            # clean up text fields to be no longer than 10000 characters
-            for key, value in log_data.items():
-                if isinstance(value, str) and len(value) > 10000:
-                    log_data[key] = value[:10000]
-            
-            self.user_logs_collection.insert_one(log_data)
-
-            # End of stream
-
-            data = json.dumps({"type": "end"})
-            yield f"data: {data}\n\n"
-        except Exception as e:
-            logger.error(f"Error in stream: {str(e)}", exc_info=True)
-            data = json.dumps(
-                {
-                    "type": "error",
-                    "error": "Please try again later. We apologize for any inconvenience.",
-                }
-            )
-            yield f"data: {data}\n\n"
-            return
-
-    def process_response_stream(self, stream):
-        """Process the stream response for non-streaming endpoint"""
-        conversation_id = ""
-        response_full = ""
-        source_log_docs = []
-        tool_calls = []
-        thought = ""
-        stream_ended = False
-        is_structured = False
-        schema_info = None
-
-        for line in stream:
-            try:
-                event_data = line.replace("data: ", "").strip()
-                event = json.loads(event_data)
-
-                if event["type"] == "id":
-                    conversation_id = event["id"]
-                elif event["type"] == "answer":
-                    response_full += event["answer"]
-                elif event["type"] == "structured_answer":
-                    response_full = event["answer"]
-                    is_structured = True
-                    schema_info = event.get("schema")
-                elif event["type"] == "source":
-                    source_log_docs = event["source"]
-                elif event["type"] == "tool_calls":
-                    tool_calls = event["tool_calls"]
-                elif event["type"] == "thought":
-                    thought = event["thought"]
-                elif event["type"] == "error":
-                    logger.error(f"Error from stream: {event['error']}")
-                    return None, None, None, None, 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 None, None, None, None, "Stream ended unexpectedly"
-
-        result = (
-            conversation_id,
-            response_full,
-            source_log_docs,
-            tool_calls,
-            thought,
-            None,
-        )
-
-        if is_structured:
-            result = result + ({"structured": True, "schema": schema_info},)
-
-        return result
-
-    def error_stream_generate(self, err_response):
-        data = json.dumps({"type": "error", "error": err_response})
-        yield f"data: {data}\n\n"

application/api/answer/routes/stream.py

@@ -1,117 +0,0 @@
-import logging
-import traceback
-
-from flask import request, Response
-from flask_restx import fields, Resource
-
-from application.api import api
-
-from application.api.answer.routes.base import answer_ns, BaseAnswerResource
-
-from application.api.answer.services.stream_processor import StreamProcessor
-
-logger = logging.getLogger(__name__)
-
-
-@answer_ns.route("/stream")
-class StreamResource(Resource, BaseAnswerResource):
-    def __init__(self, *args, **kwargs):
-        Resource.__init__(self, *args, **kwargs)
-        BaseAnswerResource.__init__(self)
-
-    stream_model = answer_ns.model(
-        "StreamModel",
-        {
-            "question": fields.String(
-                required=True, description="Question to be asked"
-            ),
-            "history": fields.List(
-                fields.String,
-                required=False,
-                description="Conversation history (only for new conversations)",
-            ),
-            "conversation_id": fields.String(
-                required=False,
-                description="Existing conversation ID (loads history)",
-            ),
-            "prompt_id": fields.String(
-                required=False, default="default", description="Prompt ID"
-            ),
-            "chunks": fields.Integer(
-                required=False, default=2, description="Number of chunks"
-            ),
-            "token_limit": fields.Integer(required=False, description="Token limit"),
-            "retriever": fields.String(required=False, description="Retriever type"),
-            "api_key": fields.String(required=False, description="API key"),
-            "active_docs": fields.String(
-                required=False, description="Active documents"
-            ),
-            "isNoneDoc": fields.Boolean(
-                required=False, description="Flag indicating if no document is used"
-            ),
-            "index": fields.Integer(
-                required=False, description="Index of the query to update"
-            ),
-            "save_conversation": fields.Boolean(
-                required=False,
-                default=True,
-                description="Whether to save the conversation",
-            ),
-            "attachments": fields.List(
-                fields.String, required=False, description="List of attachment IDs"
-            ),
-        },
-    )
-
-    @api.expect(stream_model)
-    @api.doc(description="Stream a response based on the question and retriever")
-    def post(self):
-        data = request.get_json()
-        if error := self.validate_request(data, "index" in data):
-            return error
-        decoded_token = getattr(request, "decoded_token", None)
-        processor = StreamProcessor(data, decoded_token)
-        try:
-            processor.initialize()
-            agent = processor.create_agent()
-            retriever = processor.create_retriever()
-
-            return Response(
-                self.complete_stream(
-                    question=data["question"],
-                    agent=agent,
-                    retriever=retriever,
-                    conversation_id=processor.conversation_id,
-                    user_api_key=processor.agent_config.get("user_api_key"),
-                    decoded_token=processor.decoded_token,
-                    isNoneDoc=data.get("isNoneDoc"),
-                    index=data.get("index"),
-                    should_save_conversation=data.get("save_conversation", True),
-                    attachment_ids=data.get("attachments", []),
-                    agent_id=data.get("agent_id"),
-                    is_shared_usage=processor.is_shared_usage,
-                    shared_token=processor.shared_token,
-                ),
-                mimetype="text/event-stream",
-            )
-        except ValueError as e:
-            message = "Malformed request body"
-            logger.error(
-                f"/stream - error: {message} - specific error: {str(e)} - traceback: {traceback.format_exc()}",
-                extra={"error": str(e), "traceback": traceback.format_exc()},
-            )
-            return Response(
-                self.error_stream_generate(message),
-                status=400,
-                mimetype="text/event-stream",
-            )
-        except Exception as e:
-            logger.error(
-                f"/stream - error: {str(e)} - traceback: {traceback.format_exc()}",
-                extra={"error": str(e), "traceback": traceback.format_exc()},
-            )
-            return Response(
-                self.error_stream_generate("Unknown error occurred"),
-                status=400,
-                mimetype="text/event-stream",
-            )

application/api/answer/services/conversation_service.py

@@ -1,180 +0,0 @@
-import logging
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
-
-from application.core.mongo_db import MongoDB
-
-from application.core.settings import settings
-from bson import ObjectId
-
-
-logger = logging.getLogger(__name__)
-
-
-class ConversationService:
-    def __init__(self):
-        mongo = MongoDB.get_client()
-        db = mongo[settings.MONGO_DB_NAME]
-        self.conversations_collection = db["conversations"]
-        self.agents_collection = db["agents"]
-
-    def get_conversation(
-        self, conversation_id: str, user_id: str
-    ) -> Optional[Dict[str, Any]]:
-        """Retrieve a conversation with proper access control"""
-        if not conversation_id or not user_id:
-            return None
-        try:
-            conversation = self.conversations_collection.find_one(
-                {
-                    "_id": ObjectId(conversation_id),
-                    "$or": [{"user": user_id}, {"shared_with": user_id}],
-                }
-            )
-
-            if not conversation:
-                logger.warning(
-                    f"Conversation not found or unauthorized - ID: {conversation_id}, User: {user_id}"
-                )
-                return None
-            conversation["_id"] = str(conversation["_id"])
-            return conversation
-        except Exception as e:
-            logger.error(f"Error fetching conversation: {str(e)}", exc_info=True)
-            return None
-
-    def save_conversation(
-        self,
-        conversation_id: Optional[str],
-        question: str,
-        response: str,
-        thought: str,
-        sources: List[Dict[str, Any]],
-        tool_calls: List[Dict[str, Any]],
-        llm: Any,
-        gpt_model: str,
-        decoded_token: Dict[str, Any],
-        index: Optional[int] = None,
-        api_key: Optional[str] = None,
-        agent_id: Optional[str] = None,
-        is_shared_usage: bool = False,
-        shared_token: Optional[str] = None,
-        attachment_ids: Optional[List[str]] = None,
-    ) -> str:
-        """Save or update a conversation in the database"""
-        user_id = decoded_token.get("sub")
-        if not user_id:
-            raise ValueError("User ID not found in token")
-        current_time = datetime.now(timezone.utc)
-        
-        # clean up in sources array such that we save max 1k characters for text part
-        for source in sources:
-            if "text" in source and isinstance(source["text"], str):
-                source["text"] = source["text"][:1000]
-
-        if conversation_id is not None and index is not None:
-            # Update existing conversation with new query
-
-            result = self.conversations_collection.update_one(
-                {
-                    "_id": ObjectId(conversation_id),
-                    "user": user_id,
-                    f"queries.{index}": {"$exists": True},
-                },
-                {
-                    "$set": {
-                        f"queries.{index}.prompt": question,
-                        f"queries.{index}.response": response,
-                        f"queries.{index}.thought": thought,
-                        f"queries.{index}.sources": sources,
-                        f"queries.{index}.tool_calls": tool_calls,
-                        f"queries.{index}.timestamp": current_time,
-                        f"queries.{index}.attachments": attachment_ids,
-                    }
-                },
-            )
-
-            if result.matched_count == 0:
-                raise ValueError("Conversation not found or unauthorized")
-            self.conversations_collection.update_one(
-                {
-                    "_id": ObjectId(conversation_id),
-                    "user": user_id,
-                    f"queries.{index}": {"$exists": True},
-                },
-                {"$push": {"queries": {"$each": [], "$slice": index + 1}}},
-            )
-            return conversation_id
-        elif conversation_id:
-            # Append new message to existing conversation
-
-            result = self.conversations_collection.update_one(
-                {"_id": ObjectId(conversation_id), "user": user_id},
-                {
-                    "$push": {
-                        "queries": {
-                            "prompt": question,
-                            "response": response,
-                            "thought": thought,
-                            "sources": sources,
-                            "tool_calls": tool_calls,
-                            "timestamp": current_time,
-                            "attachments": attachment_ids,
-                        }
-                    }
-                },
-            )
-
-            if result.matched_count == 0:
-                raise ValueError("Conversation not found or unauthorized")
-            return conversation_id
-        else:
-            # Create new conversation
-
-            messages_summary = [
-                {
-                    "role": "assistant",
-                    "content": "Summarise following conversation in no more than 3 "
-                    "words, respond ONLY with the summary, use the same "
-                    "language as the user query",
-                },
-                {
-                    "role": "user",
-                    "content": "Summarise following conversation in no more than 3 words, "
-                    "respond ONLY with the summary, use the same language as the "
-                    "user query \n\nUser: " + question + "\n\n" + "AI: " + response,
-                },
-            ]
-
-            completion = llm.gen(
-                model=gpt_model, messages=messages_summary, max_tokens=30
-            )
-
-            conversation_data = {
-                "user": user_id,
-                "date": current_time,
-                "name": completion,
-                "queries": [
-                    {
-                        "prompt": question,
-                        "response": response,
-                        "thought": thought,
-                        "sources": sources,
-                        "tool_calls": tool_calls,
-                        "timestamp": current_time,
-                        "attachments": attachment_ids,
-                    }
-                ],
-            }
-
-            if api_key:
-                if agent_id:
-                    conversation_data["agent_id"] = agent_id
-                    if is_shared_usage:
-                        conversation_data["is_shared_usage"] = is_shared_usage
-                        conversation_data["shared_token"] = shared_token
-                agent = self.agents_collection.find_one({"key": api_key})
-                if agent:
-                    conversation_data["api_key"] = agent["key"]
-            result = self.conversations_collection.insert_one(conversation_data)
-            return str(result.inserted_id)

application/api/answer/services/stream_processor.py

@@ -1,277 +0,0 @@
-import datetime
-import json
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from bson.dbref import DBRef
-
-from bson.objectid import ObjectId
-
-from application.agents.agent_creator import AgentCreator
-from application.api.answer.services.conversation_service import ConversationService
-from application.core.mongo_db import MongoDB
-from application.core.settings import settings
-from application.retriever.retriever_creator import RetrieverCreator
-from application.utils import get_gpt_model, limit_chat_history
-
-logger = logging.getLogger(__name__)
-
-
-def get_prompt(prompt_id: str, prompts_collection=None) -> str:
-    """
-    Get a prompt by preset name or MongoDB ID
-    """
-    current_dir = Path(__file__).resolve().parents[3]
-    prompts_dir = current_dir / "prompts"
-
-    preset_mapping = {
-        "default": "chat_combine_default.txt",
-        "creative": "chat_combine_creative.txt",
-        "strict": "chat_combine_strict.txt",
-        "reduce": "chat_reduce_prompt.txt",
-    }
-
-    if prompt_id in preset_mapping:
-        file_path = os.path.join(prompts_dir, preset_mapping[prompt_id])
-        try:
-            with open(file_path, "r") as f:
-                return f.read()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Prompt file not found: {file_path}")
-    try:
-        if prompts_collection is None:
-            mongo = MongoDB.get_client()
-            db = mongo[settings.MONGO_DB_NAME]
-            prompts_collection = db["prompts"]
-        prompt_doc = prompts_collection.find_one({"_id": ObjectId(prompt_id)})
-        if not prompt_doc:
-            raise ValueError(f"Prompt with ID {prompt_id} not found")
-        return prompt_doc["content"]
-    except Exception as e:
-        raise ValueError(f"Invalid prompt ID: {prompt_id}") from e
-
-
-class StreamProcessor:
-    def __init__(
-        self, request_data: Dict[str, Any], decoded_token: Optional[Dict[str, Any]]
-    ):
-        mongo = MongoDB.get_client()
-        self.db = mongo[settings.MONGO_DB_NAME]
-        self.agents_collection = self.db["agents"]
-        self.attachments_collection = self.db["attachments"]
-        self.prompts_collection = self.db["prompts"]
-
-        self.data = request_data
-        self.decoded_token = decoded_token
-        self.initial_user_id = (
-            self.decoded_token.get("sub") if self.decoded_token is not None else None
-        )
-        self.conversation_id = self.data.get("conversation_id")
-        self.source = (
-            {"active_docs": self.data["active_docs"]}
-            if "active_docs" in self.data
-            else {}
-        )
-        self.attachments = []
-        self.history = []
-        self.agent_config = {}
-        self.retriever_config = {}
-        self.is_shared_usage = False
-        self.shared_token = None
-        self.gpt_model = get_gpt_model()
-        self.conversation_service = ConversationService()
-
-    def initialize(self):
-        """Initialize all required components for processing"""
-        self._configure_retriever()
-        self._configure_agent()
-        self._load_conversation_history()
-        self._process_attachments()
-
-    def _load_conversation_history(self):
-        """Load conversation history either from DB or request"""
-        if self.conversation_id and self.initial_user_id:
-            conversation = self.conversation_service.get_conversation(
-                self.conversation_id, self.initial_user_id
-            )
-            if not conversation:
-                raise ValueError("Conversation not found or unauthorized")
-            self.history = [
-                {"prompt": query["prompt"], "response": query["response"]}
-                for query in conversation.get("queries", [])
-            ]
-        else:
-            self.history = limit_chat_history(
-                json.loads(self.data.get("history", "[]")), gpt_model=self.gpt_model
-            )
-
-    def _process_attachments(self):
-        """Process any attachments in the request"""
-        attachment_ids = self.data.get("attachments", [])
-        self.attachments = self._get_attachments_content(
-            attachment_ids, self.initial_user_id
-        )
-
-    def _get_attachments_content(self, attachment_ids, user_id):
-        """
-        Retrieve content from attachment documents based on their IDs.
-        """
-        if not attachment_ids:
-            return []
-        attachments = []
-        for attachment_id in attachment_ids:
-            try:
-                attachment_doc = self.attachments_collection.find_one(
-                    {"_id": ObjectId(attachment_id), "user": user_id}
-                )
-
-                if attachment_doc:
-                    attachments.append(attachment_doc)
-            except Exception as e:
-                logger.error(
-                    f"Error retrieving attachment {attachment_id}: {e}", exc_info=True
-                )
-        return attachments
-
-    def _get_agent_key(self, agent_id: Optional[str], user_id: Optional[str]) -> tuple:
-        """Get API key for agent with access control"""
-        if not agent_id:
-            return None, False, None
-        try:
-            agent = self.agents_collection.find_one({"_id": ObjectId(agent_id)})
-            if agent is None:
-                raise Exception("Agent not found")
-            is_owner = agent.get("user") == user_id
-            is_shared_with_user = agent.get(
-                "shared_publicly", False
-            ) or user_id in agent.get("shared_with", [])
-
-            if not (is_owner or is_shared_with_user):
-                raise Exception("Unauthorized access to the agent")
-            if is_owner:
-                self.agents_collection.update_one(
-                    {"_id": ObjectId(agent_id)},
-                    {
-                        "$set": {
-                            "lastUsedAt": datetime.datetime.now(datetime.timezone.utc)
-                        }
-                    },
-                )
-            return str(agent["key"]), not is_owner, agent.get("shared_token")
-        except Exception as e:
-            logger.error(f"Error in get_agent_key: {str(e)}", exc_info=True)
-            raise
-
-    def _get_data_from_api_key(self, api_key: str) -> Dict[str, Any]:
-        data = self.agents_collection.find_one({"key": api_key})
-        if not data:
-            raise Exception("Invalid API Key, please generate a new key", 401)
-        source = data.get("source")
-        if isinstance(source, DBRef):
-            source_doc = self.db.dereference(source)
-            data["source"] = str(source_doc["_id"])
-            data["retriever"] = source_doc.get("retriever", data.get("retriever"))
-            data["chunks"] = source_doc.get("chunks", data.get("chunks"))
-        else:
-            data["source"] = None
-        return data
-
-    def _configure_agent(self):
-        """Configure the agent based on request data"""
-        agent_id = self.data.get("agent_id")
-        self.agent_key, self.is_shared_usage, self.shared_token = self._get_agent_key(
-            agent_id, self.initial_user_id
-        )
-
-        api_key = self.data.get("api_key")
-        if api_key:
-            data_key = self._get_data_from_api_key(api_key)
-            self.agent_config.update(
-                {
-                    "prompt_id": data_key.get("prompt_id", "default"),
-                    "agent_type": data_key.get("agent_type", settings.AGENT_NAME),
-                    "user_api_key": api_key,
-                    "json_schema": data_key.get("json_schema"),
-                }
-            )
-            self.initial_user_id = data_key.get("user")
-            self.decoded_token = {"sub": data_key.get("user")}
-            if data_key.get("source"):
-                self.source = {"active_docs": data_key["source"]}
-            if data_key.get("retriever"):
-                self.retriever_config["retriever_name"] = data_key["retriever"]
-            if data_key.get("chunks") is not None:
-                self.retriever_config["chunks"] = data_key["chunks"]
-        elif self.agent_key:
-            data_key = self._get_data_from_api_key(self.agent_key)
-            self.agent_config.update(
-                {
-                    "prompt_id": data_key.get("prompt_id", "default"),
-                    "agent_type": data_key.get("agent_type", settings.AGENT_NAME),
-                    "user_api_key": self.agent_key,
-                    "json_schema": data_key.get("json_schema"),
-                }
-            )
-            self.decoded_token = (
-                self.decoded_token
-                if self.is_shared_usage
-                else {"sub": data_key.get("user")}
-            )
-            if data_key.get("source"):
-                self.source = {"active_docs": data_key["source"]}
-            if data_key.get("retriever"):
-                self.retriever_config["retriever_name"] = data_key["retriever"]
-            if data_key.get("chunks") is not None:
-                self.retriever_config["chunks"] = data_key["chunks"]
-        else:
-            self.agent_config.update(
-                {
-                    "prompt_id": self.data.get("prompt_id", "default"),
-                    "agent_type": settings.AGENT_NAME,
-                    "user_api_key": None,
-                    "json_schema": None,
-                }
-            )
-
-    def _configure_retriever(self):
-        """Configure the retriever based on request data"""
-        self.retriever_config = {
-            "retriever_name": self.data.get("retriever", "classic"),
-            "chunks": int(self.data.get("chunks", 2)),
-            "token_limit": self.data.get("token_limit", settings.DEFAULT_MAX_HISTORY),
-        }
-
-        if "isNoneDoc" in self.data and self.data["isNoneDoc"]:
-            self.retriever_config["chunks"] = 0
-
-    def create_agent(self):
-        """Create and return the configured agent"""
-        return AgentCreator.create_agent(
-            self.agent_config["agent_type"],
-            endpoint="stream",
-            llm_name=settings.LLM_PROVIDER,
-            gpt_model=self.gpt_model,
-            api_key=settings.API_KEY,
-            user_api_key=self.agent_config["user_api_key"],
-            prompt=get_prompt(self.agent_config["prompt_id"], self.prompts_collection),
-            chat_history=self.history,
-            decoded_token=self.decoded_token,
-            attachments=self.attachments,
-            json_schema=self.agent_config.get("json_schema"),
-        )
-
-    def create_retriever(self):
-        """Create and return the configured retriever"""
-        return RetrieverCreator.create_retriever(
-            self.retriever_config["retriever_name"],
-            source=self.source,
-            chat_history=self.history,
-            prompt=get_prompt(self.agent_config["prompt_id"], self.prompts_collection),
-            chunks=self.retriever_config["chunks"],
-            token_limit=self.retriever_config["token_limit"],
-            gpt_model=self.gpt_model,
-            user_api_key=self.agent_config["user_api_key"],
-            decoded_token=self.decoded_token,
-        )

application/api/connector/routes.py

@@ -1,627 +0,0 @@
-import datetime
-import json
-import logging
-
-
-from bson.objectid import ObjectId
-from flask import (
-    Blueprint,
-    current_app,
-    jsonify,
-    make_response,
-    request
-)
-from flask_restx import fields, Namespace, Resource
-
-
-
-
-from application.api.user.tasks import (
-    ingest_connector_task,
-)
-from application.core.mongo_db import MongoDB
-from application.core.settings import settings
-from application.api import api
-
-
-from application.utils import (
-    check_required_fields
-)
-
-
-from application.parser.connectors.connector_creator import ConnectorCreator
-
-
-
-mongo = MongoDB.get_client()
-db = mongo[settings.MONGO_DB_NAME]
-sources_collection = db["sources"]
-sessions_collection = db["connector_sessions"]
-
-connector = Blueprint("connector", __name__)
-connectors_ns = Namespace("connectors", description="Connector operations", path="/")
-api.add_namespace(connectors_ns)
-
-
-
-@connectors_ns.route("/api/connectors/upload")
-class UploadConnector(Resource):
-    @api.expect(
-        api.model(
-            "ConnectorUploadModel",
-            {
-                "user": fields.String(required=True, description="User ID"),
-                "source": fields.String(
-                    required=True, description="Source type (google_drive, github, etc.)"
-                ),
-                "name": fields.String(required=True, description="Job name"),
-                "data": fields.String(required=True, description="Configuration data"),
-                "repo_url": fields.String(description="GitHub repository URL"),
-            },
-        )
-    )
-    @api.doc(
-        description="Uploads connector source for vectorization",
-    )
-    def post(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-        data = request.form
-        required_fields = ["user", "source", "name", "data"]
-        missing_fields = check_required_fields(data, required_fields)
-        if missing_fields:
-            return missing_fields
-        try:
-            config = json.loads(data["data"])
-            source_data = None
-            sync_frequency = config.get("sync_frequency", "never")
-
-            if data["source"] == "github":
-                source_data = config.get("repo_url")
-            elif data["source"] in ["crawler", "url"]:
-                source_data = config.get("url")
-            elif data["source"] == "reddit":
-                source_data = config
-            elif data["source"] in ConnectorCreator.get_supported_connectors():
-                session_token = config.get("session_token")
-                if not session_token:
-                    return make_response(jsonify({
-                        "success": False,
-                        "error": f"Missing session_token in {data['source']} configuration"
-                    }), 400)
-
-                file_ids = config.get("file_ids", [])
-                if isinstance(file_ids, str):
-                    file_ids = [id.strip() for id in file_ids.split(',') if id.strip()]
-                elif not isinstance(file_ids, list):
-                    file_ids = []
-
-                folder_ids = config.get("folder_ids", [])
-                if isinstance(folder_ids, str):
-                    folder_ids = [id.strip() for id in folder_ids.split(',') if id.strip()]
-                elif not isinstance(folder_ids, list):
-                    folder_ids = []
-
-                config["file_ids"] = file_ids
-                config["folder_ids"] = folder_ids
-
-                task = ingest_connector_task.delay(
-                    job_name=data["name"],
-                    user=decoded_token.get("sub"),
-                    source_type=data["source"],
-                    session_token=session_token,
-                    file_ids=file_ids,
-                    folder_ids=folder_ids,
-                    recursive=config.get("recursive", False),
-                    retriever=config.get("retriever", "classic"),
-                    sync_frequency=sync_frequency
-                )
-                return make_response(jsonify({"success": True, "task_id": task.id}), 200)
-            task = ingest_connector_task.delay(
-                source_data=source_data,
-                job_name=data["name"],
-                user=decoded_token.get("sub"),
-                loader=data["source"],
-                sync_frequency=sync_frequency
-            )
-        except Exception as err:
-            current_app.logger.error(
-                f"Error uploading connector source: {err}", exc_info=True
-            )
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"success": True, "task_id": task.id}), 200)
-
-
-@connectors_ns.route("/api/connectors/task_status")
-class ConnectorTaskStatus(Resource):
-    task_status_model = api.model(
-        "ConnectorTaskStatusModel",
-        {"task_id": fields.String(required=True, description="Task ID")},
-    )
-
-    @api.expect(task_status_model)
-    @api.doc(description="Get connector task status")
-    def get(self):
-        task_id = request.args.get("task_id")
-        if not task_id:
-            return make_response(
-                jsonify({"success": False, "message": "Task ID is required"}), 400
-            )
-        try:
-            from application.celery_init import celery
-
-            task = celery.AsyncResult(task_id)
-            task_meta = task.info
-            print(f"Task status: {task.status}")
-            if not isinstance(
-                task_meta, (dict, list, str, int, float, bool, type(None))
-            ):
-                task_meta = str(task_meta)
-        except Exception as err:
-            current_app.logger.error(f"Error getting task status: {err}", exc_info=True)
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"status": task.status, "result": task_meta}), 200)
-
-
-@connectors_ns.route("/api/connectors/sources")
-class ConnectorSources(Resource):
-    @api.doc(description="Get connector sources")
-    def get(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-        user = decoded_token.get("sub")
-        try:
-            sources = sources_collection.find({"user": user, "type": "connector"}).sort("date", -1)
-            connector_sources = []
-            for source in sources:
-                connector_sources.append({
-                    "id": str(source["_id"]),
-                    "name": source.get("name"),
-                    "date": source.get("date"),
-                    "type": source.get("type"),
-                    "source": source.get("source"),
-                    "tokens": source.get("tokens", ""),
-                    "retriever": source.get("retriever", "classic"),
-                    "syncFrequency": source.get("sync_frequency", ""),
-                })
-        except Exception as err:
-            current_app.logger.error(f"Error retrieving connector sources: {err}", exc_info=True)
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify(connector_sources), 200)
-
-
-@connectors_ns.route("/api/connectors/delete")
-class DeleteConnectorSource(Resource):
-    @api.doc(
-        description="Delete a connector source",
-        params={"source_id": "The source ID to delete"},
-    )
-    def delete(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-        source_id = request.args.get("source_id")
-        if not source_id:
-            return make_response(
-                jsonify({"success": False, "message": "source_id is required"}), 400
-            )
-        try:
-            result = sources_collection.delete_one(
-                {"_id": ObjectId(source_id), "user": decoded_token.get("sub")}
-            )
-            if result.deleted_count == 0:
-                return make_response(
-                    jsonify({"success": False, "message": "Source not found"}), 404
-                )
-        except Exception as err:
-            current_app.logger.error(
-                f"Error deleting connector source: {err}", exc_info=True
-            )
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"success": True}), 200)
-
-
-@connectors_ns.route("/api/connectors/auth")
-class ConnectorAuth(Resource):
-    @api.doc(description="Get connector OAuth authorization URL", params={"provider": "Connector provider (e.g., google_drive)"})
-    def get(self):
-        try:
-            provider = request.args.get('provider') or request.args.get('source')
-            if not provider:
-                return make_response(jsonify({"success": False, "error": "Missing provider"}), 400)
-
-            if not ConnectorCreator.is_supported(provider):
-                return make_response(jsonify({"success": False, "error": f"Unsupported provider: {provider}"}), 400)
-
-            import uuid
-            state = str(uuid.uuid4())
-            auth = ConnectorCreator.create_auth(provider)
-            authorization_url = auth.get_authorization_url(state=state)
-            return make_response(jsonify({
-                "success": True,
-                "authorization_url": authorization_url,
-                "state": state
-            }), 200)
-        except Exception as e:
-            current_app.logger.error(f"Error generating connector auth URL: {e}")
-            return make_response(jsonify({"success": False, "error": str(e)}), 500)
-
-
-@connectors_ns.route("/api/connectors/callback")
-class ConnectorsCallback(Resource):
-    @api.doc(description="Handle OAuth callback for external connectors")
-    def get(self):
-        """Handle OAuth callback for external connectors"""
-        try:
-            from application.parser.connectors.connector_creator import ConnectorCreator
-            from flask import request, redirect
-            import uuid
-
-            provider = request.args.get('provider', 'google_drive')
-            authorization_code = request.args.get('code')
-            _ = request.args.get('state')
-            error = request.args.get('error')
-
-            if error:
-                return redirect(f"/api/connectors/callback-status?status=error&message=OAuth+error:+{error}.+Please+try+again+and+make+sure+to+grant+all+requested+permissions,+including+offline+access.&provider={provider}")
-
-            if not authorization_code:
-                return redirect(f"/api/connectors/callback-status?status=error&message=Authorization+code+not+provided.+Please+complete+the+authorization+process+and+make+sure+to+grant+offline+access.&provider={provider}")
-
-            try:
-                auth = ConnectorCreator.create_auth(provider)
-                token_info = auth.exchange_code_for_tokens(authorization_code)
-
-                session_token = str(uuid.uuid4())
-                
-
-                try:
-                    credentials = auth.create_credentials_from_token_info(token_info)
-                    service = auth.build_drive_service(credentials)
-                    user_info = service.about().get(fields="user").execute()
-                    user_email = user_info.get('user', {}).get('emailAddress', 'Connected User')
-                except Exception as e:
-                    current_app.logger.warning(f"Could not get user info: {e}")
-                    user_email = 'Connected User'
-
-                sanitized_token_info = {
-                    "access_token": token_info.get("access_token"),
-                    "refresh_token": token_info.get("refresh_token"),
-                    "token_uri": token_info.get("token_uri"),
-                    "expiry": token_info.get("expiry"),
-                    "scopes": token_info.get("scopes")
-                }
-
-                user_id = request.decoded_token.get("sub") if getattr(request, "decoded_token", None) else None
-                sessions_collection.insert_one({
-                    "session_token": session_token,
-                    "user": user_id,
-                    "token_info": sanitized_token_info,
-                    "created_at": datetime.datetime.now(datetime.timezone.utc),
-                    "user_email": user_email,
-                    "provider": provider
-                })
-
-                # Redirect to success page with session token and user email
-                return redirect(f"/api/connectors/callback-status?status=success&message=Authentication+successful&provider={provider}&session_token={session_token}&user_email={user_email}")
-
-            except Exception as e:
-                current_app.logger.error(f"Error exchanging code for tokens: {str(e)}", exc_info=True)
-                return redirect(f"/api/connectors/callback-status?status=error&message=Failed+to+exchange+authorization+code+for+tokens:+{str(e)}&provider={provider}")
-
-        except Exception as e:
-            current_app.logger.error(f"Error handling connector callback: {e}")
-            return redirect(f"/api/connectors/callback-status?status=error&message=Failed+to+complete+connector+authentication:+{str(e)}.+Please+try+again+and+make+sure+to+grant+all+requested+permissions,+including+offline+access.")
-
-
-@connectors_ns.route("/api/connectors/refresh")
-class ConnectorRefresh(Resource):
-    @api.expect(api.model("ConnectorRefreshModel", {"provider": fields.String(required=True), "refresh_token": fields.String(required=True)}))
-    @api.doc(description="Refresh connector access token")
-    def post(self):
-        try:
-            data = request.get_json()
-            provider = data.get('provider')
-            refresh_token = data.get('refresh_token')
-
-            if not provider or not refresh_token:
-                return make_response(jsonify({"success": False, "error": "provider and refresh_token are required"}), 400)
-
-            auth = ConnectorCreator.create_auth(provider)
-            token_info = auth.refresh_access_token(refresh_token)
-            return make_response(jsonify({"success": True, "token_info": token_info}), 200)
-        except Exception as e:
-            current_app.logger.error(f"Error refreshing token for connector: {e}")
-            return make_response(jsonify({"success": False, "error": str(e)}), 500)
-
-
-@connectors_ns.route("/api/connectors/files")
-class ConnectorFiles(Resource):
-    @api.expect(api.model("ConnectorFilesModel", {"provider": fields.String(required=True), "session_token": fields.String(required=True), "folder_id": fields.String(required=False), "limit": fields.Integer(required=False), "page_token": fields.String(required=False)}))
-    @api.doc(description="List files from a connector provider (supports pagination)")
-    def post(self):
-        try:
-            data = request.get_json()
-            provider = data.get('provider')
-            session_token = data.get('session_token')
-            folder_id = data.get('folder_id')
-            limit = data.get('limit', 10)
-            page_token = data.get('page_token')
-            if not provider or not session_token:
-                return make_response(jsonify({"success": False, "error": "provider and session_token are required"}), 400)
-
-
-            decoded_token = request.decoded_token
-            if not decoded_token:
-                return make_response(jsonify({"success": False, "error": "Unauthorized"}), 401)
-            user = decoded_token.get('sub')
-            session = sessions_collection.find_one({"session_token": session_token, "user": user})
-            if not session:
-                return make_response(jsonify({"success": False, "error": "Invalid or unauthorized session"}), 401)
-
-            loader = ConnectorCreator.create_connector(provider, session_token)
-            documents = loader.load_data({
-                'limit': limit,
-                'list_only': True,
-                'session_token': session_token,
-                'folder_id': folder_id,
-                'page_token': page_token
-            })
-
-            files = []
-            for doc in documents[:limit]:
-                metadata = doc.extra_info
-                modified_time = metadata.get('modified_time')
-                if modified_time:
-                    date_part = modified_time.split('T')[0]
-                    time_part = modified_time.split('T')[1].split('.')[0].split('Z')[0]
-                    formatted_time = f"{date_part} {time_part}"
-                else:
-                    formatted_time = None
-
-                files.append({
-                    'id': doc.doc_id,
-                    'name': metadata.get('file_name', 'Unknown File'),
-                    'type': metadata.get('mime_type', 'unknown'),
-                    'size': metadata.get('size', None),
-                    'modifiedTime': formatted_time
-                })
-
-            next_token = getattr(loader, 'next_page_token', None)
-            has_more = bool(next_token)
-
-            return make_response(jsonify({"success": True, "files": files, "total": len(files), "next_page_token": next_token, "has_more": has_more}), 200)
-        except Exception as e:
-            current_app.logger.error(f"Error loading connector files: {e}")
-            return make_response(jsonify({"success": False, "error": f"Failed to load files: {str(e)}"}), 500)
-
-
-@connectors_ns.route("/api/connectors/validate-session")
-class ConnectorValidateSession(Resource):
-    @api.expect(api.model("ConnectorValidateSessionModel", {"provider": fields.String(required=True), "session_token": fields.String(required=True)}))
-    @api.doc(description="Validate connector session token and return user info")
-    def post(self):
-        try:
-            data = request.get_json()
-            provider = data.get('provider')
-            session_token = data.get('session_token')
-            if not provider or not session_token:
-                return make_response(jsonify({"success": False, "error": "provider and session_token are required"}), 400)
-
-
-            decoded_token = request.decoded_token
-            if not decoded_token:
-                return make_response(jsonify({"success": False, "error": "Unauthorized"}), 401)
-            user = decoded_token.get('sub')
-
-            session = sessions_collection.find_one({"session_token": session_token, "user": user})
-            if not session or "token_info" not in session:
-                return make_response(jsonify({"success": False, "error": "Invalid or expired session"}), 401)
-
-            token_info = session["token_info"]
-            auth = ConnectorCreator.create_auth(provider)
-            is_expired = auth.is_token_expired(token_info)
-
-            return make_response(jsonify({
-                "success": True,
-                "expired": is_expired,
-                "user_email": session.get('user_email', 'Connected User')
-            }), 200)
-        except Exception as e:
-            current_app.logger.error(f"Error validating connector session: {e}")
-            return make_response(jsonify({"success": False, "error": str(e)}), 500)
-
-
-@connectors_ns.route("/api/connectors/disconnect")
-class ConnectorDisconnect(Resource):
-    @api.expect(api.model("ConnectorDisconnectModel", {"provider": fields.String(required=True), "session_token": fields.String(required=False)}))
-    @api.doc(description="Disconnect a connector session")
-    def post(self):
-        try:
-            data = request.get_json()
-            provider = data.get('provider')
-            session_token = data.get('session_token')
-            if not provider:
-                return make_response(jsonify({"success": False, "error": "provider is required"}), 400)
-
-
-            if session_token:
-                sessions_collection.delete_one({"session_token": session_token})
-            
-            return make_response(jsonify({"success": True}), 200)
-        except Exception as e:
-            current_app.logger.error(f"Error disconnecting connector session: {e}")
-            return make_response(jsonify({"success": False, "error": str(e)}), 500)
-
-
-@connectors_ns.route("/api/connectors/sync")
-class ConnectorSync(Resource):
-    @api.expect(
-        api.model(
-            "ConnectorSyncModel",
-            {
-                "source_id": fields.String(required=True, description="Source ID to sync"),
-                "session_token": fields.String(required=True, description="Authentication token")
-            },
-        )
-    )
-    @api.doc(description="Sync connector source to check for modifications")
-    def post(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-
-        try:
-            data = request.get_json()
-            source_id = data.get('source_id')
-            session_token = data.get('session_token')
-
-            if not all([source_id, session_token]):
-                return make_response(
-                    jsonify({
-                        "success": False,
-                        "error": "source_id and session_token are required"
-                    }), 
-                    400
-                )
-            source = sources_collection.find_one({"_id": ObjectId(source_id)})
-            if not source:
-                return make_response(
-                    jsonify({
-                        "success": False,
-                        "error": "Source not found"
-                    }), 
-                    404
-                )
-
-            if source.get('user') != decoded_token.get('sub'):
-                return make_response(
-                    jsonify({
-                        "success": False,
-                        "error": "Unauthorized access to source"
-                    }), 
-                    403
-                )
-
-            remote_data = {}
-            try:
-                if source.get('remote_data'):
-                    remote_data = json.loads(source.get('remote_data'))
-            except json.JSONDecodeError:
-                current_app.logger.error(f"Invalid remote_data format for source {source_id}")
-                remote_data = {}
-
-            source_type = remote_data.get('provider')
-            if not source_type:
-                return make_response(
-                    jsonify({
-                        "success": False,
-                        "error": "Source provider not found in remote_data"
-                    }), 
-                    400
-                )
-
-            # Extract configuration from remote_data
-            file_ids = remote_data.get('file_ids', [])
-            folder_ids = remote_data.get('folder_ids', [])
-            recursive = remote_data.get('recursive', True)
-
-            # Start the sync task
-            task = ingest_connector_task.delay(
-                job_name=source.get('name'),
-                user=decoded_token.get('sub'),
-                source_type=source_type,
-                session_token=session_token,
-                file_ids=file_ids,
-                folder_ids=folder_ids,
-                recursive=recursive,
-                retriever=source.get('retriever', 'classic'),
-                operation_mode="sync",
-                doc_id=source_id,
-                sync_frequency=source.get('sync_frequency', 'never')
-            )
-
-            return make_response(
-                jsonify({
-                    "success": True,
-                    "task_id": task.id
-                }), 
-                200
-            )
-
-        except Exception as err:
-            current_app.logger.error(
-                f"Error syncing connector source: {err}",
-                exc_info=True
-            )
-            return make_response(
-                jsonify({
-                    "success": False,
-                    "error": str(err)
-                }), 
-                400
-            )
-
-
-@connectors_ns.route("/api/connectors/callback-status")
-class ConnectorCallbackStatus(Resource):
-    @api.doc(description="Return HTML page with connector authentication status")
-    def get(self):
-        """Return HTML page with connector authentication status"""
-        try:
-            status = request.args.get('status', 'error')
-            message = request.args.get('message', '')
-            provider = request.args.get('provider', 'connector')
-            session_token = request.args.get('session_token', '')
-            user_email = request.args.get('user_email', '')
-            
-            html_content = f"""
-            <!DOCTYPE html>
-            <html>
-            <head>
-                <title>{provider.replace('_', ' ').title()} Authentication</title>
-                <style>
-                    body {{ font-family: Arial, sans-serif; text-align: center; padding: 40px; }}
-                    .container {{ max-width: 600px; margin: 0 auto; }}
-                    .success {{ color: #4CAF50; }}
-                    .error {{ color: #F44336; }}
-                </style>
-                <script>
-                    window.onload = function() {{
-                        const status = "{status}";
-                        const sessionToken = "{session_token}";
-                        const userEmail = "{user_email}";
-                        
-                        if (status === "success" && window.opener) {{
-                            window.opener.postMessage({{
-                                type: '{provider}_auth_success',
-                                session_token: sessionToken,
-                                user_email: userEmail
-                            }}, '*');
-                            
-                            setTimeout(() => window.close(), 3000);
-                        }}
-                    }};
-                </script>
-            </head>
-            <body>
-                <div class="container">
-                    <h2>{provider.replace('_', ' ').title()} Authentication</h2>
-                    <div class="{status}">
-                        <p>{message}</p>
-                        {f'<p>Connected as: {user_email}</p>' if status == 'success' else ''}
-                    </div>
-                    <p><small>You can close this window. {f"Your {provider.replace('_', ' ').title()} is now connected and ready to use." if status == 'success' else ''}</small></p>
-                </div>
-            </body>
-            </html>
-            """
-            
-            return make_response(html_content, 200, {'Content-Type': 'text/html'})
-        except Exception as e:
-            current_app.logger.error(f"Error rendering callback status page: {e}")
-            return make_response("Authentication error occurred", 500, {'Content-Type': 'text/html'})
-
-

application/api/internal/routes.py

@@ -1,18 +1,14 @@
 import os
 import datetime
-import json
 from flask import Blueprint, request, send_from_directory
 from werkzeug.utils import secure_filename
 from bson.objectid import ObjectId
-import logging
+
 from application.core.mongo_db import MongoDB
 from application.core.settings import settings
-from application.storage.storage_creator import StorageCreator
 
-
-logger = logging.getLogger(__name__)
 mongo = MongoDB.get_client()
-db = mongo[settings.MONGO_DB_NAME]
+db = mongo["docsgpt"]
 conversations_collection = db["conversations"]
 sources_collection = db["sources"]
 
@@ -38,52 +34,37 @@ def upload_index_files():
     """Upload two files(index.faiss, index.pkl) to the user's folder."""
     if "user" not in request.form:
         return {"status": "no user"}
-    user = request.form["user"] 
+    user = secure_filename(request.form["user"])
     if "name" not in request.form:
         return {"status": "no name"}
-    job_name = request.form["name"]
-    tokens = request.form["tokens"]
-    retriever = request.form["retriever"]
-    id = request.form["id"]
-    type = request.form["type"]
+    job_name = secure_filename(request.form["name"])
+    tokens = secure_filename(request.form["tokens"])
+    retriever = secure_filename(request.form["retriever"])
+    id = secure_filename(request.form["id"])
+    type = secure_filename(request.form["type"])
     remote_data = request.form["remote_data"] if "remote_data" in request.form else None
-    sync_frequency = request.form["sync_frequency"] if "sync_frequency" in request.form else None
-    
-    file_path = request.form.get("file_path")
-    directory_structure = request.form.get("directory_structure")
-    
-    if directory_structure:
-        try:
-            directory_structure = json.loads(directory_structure)
-        except Exception:
-            logger.error("Error parsing directory_structure")
-            directory_structure = {}
-    else:
-        directory_structure = {}
+    sync_frequency = secure_filename(request.form["sync_frequency"]) if "sync_frequency" in request.form else None
 
-    storage = StorageCreator.get_storage()
-    index_base_path = f"indexes/{id}"
-    
+    save_dir = os.path.join(current_dir, "indexes", str(id))
     if settings.VECTOR_STORE == "faiss":
         if "file_faiss" not in request.files:
-            logger.error("No file_faiss part")
+            print("No file part")
             return {"status": "no file"}
         file_faiss = request.files["file_faiss"]
         if file_faiss.filename == "":
             return {"status": "no file name"}
         if "file_pkl" not in request.files:
-            logger.error("No file_pkl part")
+            print("No file part")
             return {"status": "no file"}
         file_pkl = request.files["file_pkl"]
         if file_pkl.filename == "":
             return {"status": "no file name"}
+        # saves index files
 
-        # Save index files to storage
-        faiss_storage_path = f"{index_base_path}/index.faiss"
-        pkl_storage_path = f"{index_base_path}/index.pkl"
-        storage.save_file(file_faiss, faiss_storage_path)
-        storage.save_file(file_pkl, pkl_storage_path)
-
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+        file_faiss.save(os.path.join(save_dir, "index.faiss"))
+        file_pkl.save(os.path.join(save_dir, "index.pkl"))
 
     existing_entry = sources_collection.find_one({"_id": ObjectId(id)})
     if existing_entry:
@@ -101,8 +82,6 @@ def upload_index_files():
                     "retriever": retriever,
                     "remote_data": remote_data,
                     "sync_frequency": sync_frequency,
-                    "file_path": file_path,
-                    "directory_structure": directory_structure,
                 }
             },
         )
@@ -120,8 +99,6 @@ def upload_index_files():
                 "retriever": retriever,
                 "remote_data": remote_data,
                 "sync_frequency": sync_frequency,
-                "file_path": file_path,
-                "directory_structure": directory_structure,
             }
         )
     return {"status": "ok"}

application/api/user/tasks.py

@@ -1,18 +1,12 @@
 from datetime import timedelta
 
 from application.celery_init import celery
-from application.worker import (
-    agent_webhook_worker,
-    attachment_worker,
-    ingest_worker,
-    remote_worker,
-    sync_worker,
-)
+from application.worker import ingest_worker, remote_worker, sync_worker
 
 
 @celery.task(bind=True)
-def ingest(self, directory, formats, job_name, user, file_path, filename):
-    resp = ingest_worker(self, directory, formats, job_name, file_path, filename, user)
+def ingest(self, directory, formats, name_job, filename, user):
+    resp = ingest_worker(self, directory, formats, name_job, filename, user)
     return resp
 
 
@@ -22,64 +16,12 @@ def ingest_remote(self, source_data, job_name, user, loader):
     return resp
 
 
-@celery.task(bind=True)
-def reingest_source_task(self, source_id, user):
-    from application.worker import reingest_source_worker
-    resp = reingest_source_worker(self, source_id, user)
-    return resp
-
-
 @celery.task(bind=True)
 def schedule_syncs(self, frequency):
     resp = sync_worker(self, frequency)
     return resp
 
 
-@celery.task(bind=True)
-def store_attachment(self, file_info, user):
-    resp = attachment_worker(self, file_info, user)
-    return resp
-
-
-@celery.task(bind=True)
-def process_agent_webhook(self, agent_id, payload):
-    resp = agent_webhook_worker(self, agent_id, payload)
-    return resp
-
-
-@celery.task(bind=True)
-def ingest_connector_task(
-    self,
-    job_name,
-    user,
-    source_type,
-    session_token=None,
-    file_ids=None,
-    folder_ids=None,
-    recursive=True,
-    retriever="classic",
-    operation_mode="upload",
-    doc_id=None,
-    sync_frequency="never"
-):
-    from application.worker import ingest_connector
-    resp = ingest_connector(
-        self,
-        job_name,
-        user,
-        source_type,
-        session_token=session_token,
-        file_ids=file_ids,
-        folder_ids=folder_ids,
-        recursive=recursive,
-        retriever=retriever,
-        operation_mode=operation_mode,
-        doc_id=doc_id,
-        sync_frequency=sync_frequency
-    )
-    return resp
-
-
 @celery.on_after_configure.connect
 def setup_periodic_tasks(sender, **kwargs):
     sender.add_periodic_task(

application/app.py

@@ -1,37 +1,28 @@
-import os
 import platform
-import uuid
 
 import dotenv
-from flask import Flask, jsonify, redirect, request
-from jose import jwt
-
-from application.auth import handle_auth
+from flask import Flask, redirect, request
 
+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
-
-setup_logging()
-
-from application.api import api  # noqa: E402
-from application.api.answer import answer  # noqa: E402
-from application.api.internal.routes import internal  # noqa: E402
-from application.api.user.routes import user  # noqa: E402
-from application.api.connector.routes import connector  # noqa: E402
-from application.celery_init import celery  # noqa: E402
-from application.core.settings import settings  # noqa: E402
-
+from application.core.settings import settings
+from application.extensions import api
 
 if platform.system() == "Windows":
     import pathlib
 
     pathlib.PosixPath = pathlib.WindowsPath
+
 dotenv.load_dotenv()
+setup_logging()
 
 app = Flask(__name__)
 app.register_blueprint(user)
 app.register_blueprint(answer)
 app.register_blueprint(internal)
-app.register_blueprint(connector)
 app.config.update(
     UPLOAD_FOLDER="inputs",
     CELERY_BROKER_URL=settings.CELERY_BROKER_URL,
@@ -41,24 +32,6 @@ 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():
@@ -68,46 +41,11 @@ 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, POST, PUT, DELETE, OPTIONS"
-    )
+    response.headers.add("Access-Control-Allow-Headers", "Content-Type,Authorization")
+    response.headers.add("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE,OPTIONS")
     return response
 
 

application/auth.py

@@ -1,28 +0,0 @@
-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,117 +1,93 @@
+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, _redis_creation_failed
-    if _redis_instance is None and not _redis_creation_failed:
+    global _redis_instance
+    if _redis_instance is None:
         with _instance_lock:
-            if _redis_instance is None and not _redis_creation_failed:
+            if _redis_instance is None:
                 try:
-                    _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
+                    _redis_instance = redis.Redis.from_url(settings.CACHE_REDIS_URL, socket_connect_timeout=2)
                 except redis.ConnectionError as e:
                     logger.error(f"Redis connection error: {e}")
-                    _redis_instance = None  # Keep trying for connection errors
+                    _redis_instance = None
     return _redis_instance
 
-
-def gen_cache_key(messages, model="docgpt", tools=None):
+def gen_cache_key(*messages, model="docgpt"):
     if not all(isinstance(msg, dict) for msg in messages):
         raise ValueError("All messages must be dictionaries.")
-    messages_str = json.dumps(messages)
-    tools_str = json.dumps(str(tools)) if tools else ""
-    combined = f"{model}_{messages_str}_{tools_str}"
+    messages_str = json.dumps(list(messages), sort_keys=True)
+    combined = f"{model}_{messages_str}"
     cache_key = get_hash(combined)
     return cache_key
 
-
 def gen_cache(func):
-    def wrapper(self, model, messages, stream, tools=None, *args, **kwargs):
-        if tools is not None:
-            return func(self, model, messages, stream, tools, *args, **kwargs)
-        
+    def wrapper(self, model, messages, *args, **kwargs):
         try:
-            cache_key = gen_cache_key(messages, model, tools)
+            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
         except ValueError as e:
-            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}", exc_info=True)
-
-        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}", exc_info=True)
-
-        return result
-
+            logger.error(e)
+            return "Error: No user message found in the conversation to generate a cache key."
     return wrapper
 
-
 def stream_cache(func):
-    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
+    def wrapper(self, model, messages, stream, *args, **kwargs):
+        cache_key = gen_cache_key(*messages)
+        logger.info(f"Stream cache key: {cache_key}")
         
-        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)  # Simulate streaming delay
+                        time.sleep(0.03)
                     return
-            except Exception as e:
-                logger.error(f"Error getting cached stream: {e}", exc_info=True)
+            except redis.ConnectionError as e:
+                logger.error(f"Redis connection error: {e}")
 
+        result = func(self, model, messages, stream, *args, **kwargs)
         stream_cache_data = []
-        for chunk in func(self, model, messages, stream, tools, *args, **kwargs):
+        
+        for chunk in result:
+            stream_cache_data.append(chunk)
             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 Exception as e:
-                logger.error(f"Error setting stream cache: {e}", exc_info=True)
-
-    return wrapper
+            except redis.ConnectionError as e:
+                logger.error(f"Redis connection error: {e}")
+        
+    return wrapper

application/celery_init.py

@@ -2,22 +2,14 @@ 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,51 +1,25 @@
-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  # simple_jwt, session_jwt, or None
-    LLM_PROVIDER: str = "docsgpt"
-    LLM_NAME: Optional[str] = (
-        None  # if LLM_PROVIDER is openai, LLM_NAME can be gpt-4 or gpt-3.5-turbo
-    )
+    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
     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"
-    MONGO_DB_NAME: str = "docsgpt"
-    LLM_PATH: str = os.path.join(current_dir, "models/docsgpt-7b-f16.gguf")
+    MODEL_PATH: str = os.path.join(current_dir, "models/docsgpt-7b-f16.gguf")
     DEFAULT_MAX_HISTORY: int = 150
-    LLM_TOKEN_LIMITS: dict = {
-        "gpt-4o-mini": 128000,
-        "gpt-3.5-turbo": 4096,
-        "claude-2": 1e5,
-        "gemini-2.0-flash-exp": 1e6,
-    }
+    MODEL_TOKEN_LIMITS: dict = {"gpt-3.5-turbo": 4096, "claude-2": 1e5}
     UPLOAD_FOLDER: str = "inputs"
-    PARSE_PDF_AS_IMAGE: bool = False
-    PARSE_IMAGE_REMOTE: bool = False
-    VECTOR_STORE: str = (
-        "faiss"  #  "faiss" or "elasticsearch" or "qdrant" or "milvus" or "lancedb"
-    )
-    RETRIEVERS_ENABLED: list = ["classic_rag"]
-    AGENT_NAME: str = "classic"
-    FALLBACK_LLM_PROVIDER: Optional[str] = None  # provider for fallback llm
-    FALLBACK_LLM_NAME: Optional[str] = None  # model name for fallback llm
-    FALLBACK_LLM_API_KEY: Optional[str] = None  # api key for fallback llm
-
-    # Google Drive integration
-    GOOGLE_CLIENT_ID: Optional[str] = None # Replace with your actual Google OAuth client ID
-    GOOGLE_CLIENT_SECRET: Optional[str] = None# Replace with your actual Google OAuth client secret
-    CONNECTOR_REDIRECT_BASE_URI: Optional[str] = "http://127.0.0.1:7091/api/connectors/callback" 
-    ##append ?provider={provider_name} in your Provider console like http://127.0.0.1:7091/api/connectors/callback?provider=google_drive
-
+    VECTOR_STORE: str = "faiss" #  "faiss" or "elasticsearch" or "qdrant" or "milvus" or "lancedb"
+    RETRIEVERS_ENABLED: list = ["classic_rag", "duckduck_search"] # also brave_search
 
     # LLM Cache
     CACHE_REDIS_URL: str = "redis://localhost:6379/2"
@@ -53,18 +27,12 @@ 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
@@ -96,25 +64,18 @@ class Settings(BaseSettings):
     QDRANT_HOST: Optional[str] = None
     QDRANT_PATH: Optional[str] = None
     QDRANT_DISTANCE_FUNC: str = "Cosine"
-    
-    # PGVector vectorstore config
-    PGVECTOR_CONNECTION_STRING: Optional[str] = None
+
     # 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
-    STORAGE_TYPE: str = "local"  # local or s3
-    URL_STRATEGY: str = "backend"  # backend or s3
-
-    JWT_SECRET_KEY: str = ""
 
 
 path = Path(__file__).parent.parent.absolute()

application/extensions.py

@@ -0,0 +1,7 @@
+from flask_restx import Api
+
+api = Api(
+    version="1.0",
+    title="DocsGPT API",
+    description="API for DocsGPT",
+)

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, tools=None, max_tokens=300, **kwargs
+        self, baseself, model, messages, stream=False, 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, tools=None, max_tokens=300, **kwargs
+        self, baseself, model, messages, stream=True, max_tokens=300, **kwargs
     ):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]

application/llm/base.py

@@ -1,144 +1,29 @@
-import logging
 from abc import ABC, abstractmethod
-
-from application.cache import gen_cache, stream_cache
-
-from application.core.settings import settings
 from application.usage import gen_token_usage, stream_token_usage
-
-logger = logging.getLogger(__name__)
+from application.cache import stream_cache, gen_cache
 
 
 class BaseLLM(ABC):
-    def __init__(
-        self,
-        decoded_token=None,
-    ):
-        self.decoded_token = decoded_token
+    def __init__(self):
         self.token_usage = {"prompt_tokens": 0, "generated_tokens": 0}
-        self.fallback_provider = settings.FALLBACK_LLM_PROVIDER
-        self.fallback_model_name = settings.FALLBACK_LLM_NAME
-        self.fallback_llm_api_key = settings.FALLBACK_LLM_API_KEY
-        self._fallback_llm = None
 
-    @property
-    def fallback_llm(self):
-        """Lazy-loaded fallback LLM instance."""
-        if (
-            self._fallback_llm is None
-            and self.fallback_provider
-            and self.fallback_model_name
-        ):
-            try:
-                from application.llm.llm_creator import LLMCreator
-
-                self._fallback_llm = LLMCreator.create_llm(
-                    self.fallback_provider,
-                    self.fallback_llm_api_key,
-                    None,
-                    self.decoded_token,
-                )
-            except Exception as e:
-                logger.error(
-                    f"Failed to initialize fallback LLM: {str(e)}", exc_info=True
-                )
-        return self._fallback_llm
-
-    def _execute_with_fallback(
-        self, method_name: str, decorators: list, *args, **kwargs
-    ):
-        """
-        Unified method execution with fallback support.
-
-        Args:
-            method_name: Name of the raw method ('_raw_gen' or '_raw_gen_stream')
-            decorators: List of decorators to apply
-            *args: Positional arguments
-            **kwargs: Keyword arguments
-        """
-
-        def decorated_method():
-            method = getattr(self, method_name)
-            for decorator in decorators:
-                method = decorator(method)
-            return method(self, *args, **kwargs)
-
-        try:
-            return decorated_method()
-        except Exception as e:
-            if not self.fallback_llm:
-                logger.error(f"Primary LLM failed and no fallback available: {str(e)}")
-                raise
-            logger.warning(
-                f"Falling back to {self.fallback_provider}/{self.fallback_model_name}. Error: {str(e)}"
-            )
-
-            fallback_method = getattr(
-                self.fallback_llm, method_name.replace("_raw_", "")
-            )
-            return fallback_method(*args, **kwargs)
-
-    def gen(self, model, messages, stream=False, tools=None, *args, **kwargs):
-        decorators = [gen_token_usage, gen_cache]
-        return self._execute_with_fallback(
-            "_raw_gen",
-            decorators,
-            model=model,
-            messages=messages,
-            stream=stream,
-            tools=tools,
-            *args,
-            **kwargs,
-        )
-
-    def gen_stream(self, model, messages, stream=True, tools=None, *args, **kwargs):
-        decorators = [stream_cache, stream_token_usage]
-        return self._execute_with_fallback(
-            "_raw_gen_stream",
-            decorators,
-            model=model,
-            messages=messages,
-            stream=stream,
-            tools=tools,
-            *args,
-            **kwargs,
-        )
+    def _apply_decorator(self, method, decorators, *args, **kwargs):
+        for decorator in decorators:
+            method = decorator(method)
+        return method(self, *args, **kwargs)
 
     @abstractmethod
-    def _raw_gen(self, model, messages, stream, tools, *args, **kwargs):
+    def _raw_gen(self, model, messages, stream, *args, **kwargs):
         pass
 
+    def gen(self, model, messages, stream=False, *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)
+
     @abstractmethod
     def _raw_gen_stream(self, model, messages, stream, *args, **kwargs):
         pass
 
-    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")
-
-    def supports_structured_output(self):
-        """Check if the LLM supports structured output/JSON schema enforcement"""
-        return hasattr(self, "_supports_structured_output") and callable(
-            getattr(self, "_supports_structured_output")
-        )
-
-    def _supports_structured_output(self):
-        return False
-
-    def prepare_structured_output_format(self, json_schema):
-        """Prepare structured output format specific to the LLM provider"""
-        _ = json_schema
-        return None
-
-    def get_supported_attachment_types(self):
-        """
-        Return a list of MIME types supported by this LLM for file uploads.
-
-        Returns:
-            list: List of supported MIME types
-        """
-        return []
+    def gen_stream(self, model, messages, stream=True, *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)

application/llm/docsgpt_provider.py

@@ -1,131 +1,34 @@
-import json
-
-from application.core.settings import settings
 from application.llm.base import BaseLLM
+import json
+import requests
 
 
 class DocsGPTAPILLM(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="sk-docsgpt-public", base_url="https://oai.arc53.com")
-        self.user_api_key = user_api_key
         self.api_key = api_key
+        self.user_api_key = user_api_key
+        self.endpoint = "https://llm.arc53.com"
 
-    def _clean_messages_openai(self, messages):
-        cleaned_messages = []
-        for message in messages:
-            role = message.get("role")
-            content = message.get("content")
+    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("###", "")
 
-            if role == "model":
-                role = "assistant"
+        return response_clean
 
-            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)}")
+    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,
+        )
 
-        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
+        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"]

application/llm/google_ai.py

@@ -1,235 +1,21 @@
-import json
-import logging
-
-from google import genai
-from google.genai import types
-
-from application.core.settings import settings
-
 from application.llm.base import BaseLLM
-from application.storage.storage_creator import StorageCreator
-
 
 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
-        self.client = genai.Client(api_key=self.api_key)
-        self.storage = StorageCreator.get_storage()
-
-    def get_supported_attachment_types(self):
-        """
-        Return a list of MIME types supported by Google Gemini for file uploads.
-
-        Returns:
-            list: List of supported MIME types
-        """
-        return [
-            "application/pdf",
-            "image/png",
-            "image/jpeg",
-            "image/jpg",
-            "image/webp",
-            "image/gif",
-        ]
-
-    def prepare_messages_with_attachments(self, messages, attachments=None):
-        """
-        Process attachments using Google AI's file API for more efficient handling.
-
-        Args:
-            messages (list): List of message dictionaries.
-            attachments (list): List of attachment dictionaries with content and metadata.
-
-        Returns:
-            list: Messages formatted with file references for Google AI API.
-        """
-        if not attachments:
-            return messages
-
-        prepared_messages = messages.copy()
-
-        # Find the user message to attach files to the last one
-        user_message_index = None
-        for i in range(len(prepared_messages) - 1, -1, -1):
-            if prepared_messages[i].get("role") == "user":
-                user_message_index = i
-                break
-
-        if user_message_index is None:
-            user_message = {"role": "user", "content": []}
-            prepared_messages.append(user_message)
-            user_message_index = len(prepared_messages) - 1
-
-        if isinstance(prepared_messages[user_message_index].get("content"), str):
-            text_content = prepared_messages[user_message_index]["content"]
-            prepared_messages[user_message_index]["content"] = [
-                {"type": "text", "text": text_content}
-            ]
-        elif not isinstance(prepared_messages[user_message_index].get("content"), list):
-            prepared_messages[user_message_index]["content"] = []
-
-        files = []
-        for attachment in attachments:
-            mime_type = attachment.get("mime_type")
-
-            if mime_type in self.get_supported_attachment_types():
-                try:
-                    file_uri = self._upload_file_to_google(attachment)
-                    logging.info(
-                        f"GoogleLLM: Successfully uploaded file, got URI: {file_uri}"
-                    )
-                    files.append({"file_uri": file_uri, "mime_type": mime_type})
-                except Exception as e:
-                    logging.error(
-                        f"GoogleLLM: Error uploading file: {e}", exc_info=True
-                    )
-                    if "content" in attachment:
-                        prepared_messages[user_message_index]["content"].append(
-                            {
-                                "type": "text",
-                                "text": f"[File could not be processed: {attachment.get('path', 'unknown')}]",
-                            }
-                        )
-
-        if files:
-            logging.info(f"GoogleLLM: Adding {len(files)} files to message")
-            prepared_messages[user_message_index]["content"].append({"files": files})
-
-        return prepared_messages
-
-    def _upload_file_to_google(self, attachment):
-        """
-        Upload a file to Google AI and return the file URI.
-
-        Args:
-            attachment (dict): Attachment dictionary with path and metadata.
-
-        Returns:
-            str: Google AI file URI for the uploaded file.
-        """
-        if "google_file_uri" in attachment:
-            return attachment["google_file_uri"]
-
-        file_path = attachment.get("path")
-        if not file_path:
-            raise ValueError("No file path provided in attachment")
-
-        if not self.storage.file_exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        try:
-            file_uri = self.storage.process_file(
-                file_path,
-                lambda local_path, **kwargs: self.client.files.upload(
-                    file=local_path
-                ).uri,
-            )
-
-            from application.core.mongo_db import MongoDB
-
-            mongo = MongoDB.get_client()
-            db = mongo[settings.MONGO_DB_NAME]
-            attachments_collection = db["attachments"]
-            if "_id" in attachment:
-                attachments_collection.update_one(
-                    {"_id": attachment["_id"]}, {"$set": {"google_file_uri": file_uri}}
-                )
-
-            return file_uri
-        except Exception as e:
-            logging.error(f"Error uploading file to Google AI: {e}", exc_info=True)
-            raise
 
     def _clean_messages_google(self, messages):
-        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(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"],
-                                )
-                            )
-                        elif "files" in item:
-                            for file_data in item["files"]:
-                                parts.append(
-                                    types.Part.from_uri(
-                                        file_uri=file_data["file_uri"],
-                                        mime_type=file_data["mime_type"],
-                                    )
-                                )
-                        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
+        return [
+            {
+                "role": "model" if message["role"] == "system" else message["role"],
+                "parts": [message["content"]],
+            }
+            for message in messages[1:]
+        ]
 
     def _raw_gen(
         self,
@@ -237,38 +23,13 @@ class GoogleLLM(BaseLLM):
         model,
         messages,
         stream=False,
-        tools=None,
-        formatting="openai",
-        response_schema=None,
-        **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
-
-        # Add response schema for structured output if provided
-        if response_schema:
-            config.response_schema = response_schema
-            config.response_mime_type = "application/json"
-
-        response = client.models.generate_content(
-            model=model,
-            contents=messages,
-            config=config,
-        )
-
-        if tools:
-            return response
-        else:
-            return response.text
+        **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
 
     def _raw_gen_stream(
         self,
@@ -276,131 +37,12 @@ class GoogleLLM(BaseLLM):
         model,
         messages,
         stream=True,
-        tools=None,
-        formatting="openai",
-        response_schema=None,
-        **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
-
-        # Add response schema for structured output if provided
-        if response_schema:
-            config.response_schema = response_schema
-            config.response_mime_type = "application/json"
-
-        # Check if we have both tools and file attachments
-        has_attachments = False
-        for message in messages:
-            for part in message.parts:
-                if hasattr(part, "file_data") and part.file_data is not None:
-                    has_attachments = True
-                    break
-            if has_attachments:
-                break
-
-        logging.info(
-            f"GoogleLLM: Starting stream generation. Model: {model}, Messages: {json.dumps(messages, default=str)}, Has attachments: {has_attachments}"
-        )
-
-        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
-
-    def _supports_structured_output(self):
-        return True
-
-    def prepare_structured_output_format(self, json_schema):
-        if not json_schema:
-            return None
-
-        type_map = {
-            "object": "OBJECT",
-            "array": "ARRAY",
-            "string": "STRING",
-            "integer": "INTEGER",
-            "number": "NUMBER",
-            "boolean": "BOOLEAN",
-        }
-
-        def convert(schema):
-            if not isinstance(schema, dict):
-                return schema
-
-            result = {}
-            schema_type = schema.get("type")
-            if schema_type:
-                result["type"] = type_map.get(schema_type.lower(), schema_type.upper())
-
-            for key in [
-                "description",
-                "nullable",
-                "enum",
-                "minItems",
-                "maxItems",
-                "required",
-                "propertyOrdering",
-            ]:
-                if key in schema:
-                    result[key] = schema[key]
-
-            if "format" in schema:
-                format_value = schema["format"]
-                if schema_type == "string":
-                    if format_value == "date":
-                        result["format"] = "date-time"
-                    elif format_value in ["enum", "date-time"]:
-                        result["format"] = format_value
-                else:
-                    result["format"] = format_value
-
-            if "properties" in schema:
-                result["properties"] = {
-                    k: convert(v) for k, v in schema["properties"].items()
-                }
-                if "propertyOrdering" not in result and result.get("type") == "OBJECT":
-                    result["propertyOrdering"] = list(result["properties"].keys())
-
-            if "items" in schema:
-                result["items"] = convert(schema["items"])
-
-            for field in ["anyOf", "oneOf", "allOf"]:
-                if field in schema:
-                    result[field] = [convert(s) for s in schema[field]]
-
-            return result
-
-        try:
-            return convert(json_schema)
-        except Exception as e:
-            logging.error(
-                f"Error preparing structured output format for Google: {e}",
-                exc_info=True,
-            )
-            return None
+        **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

application/llm/groq.py

@@ -1,32 +1,45 @@
 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, 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
-    ):
+    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_stream(
+        self,
+        baseself,
+        model,
+        messages,
+        stream=True,
+        **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/handlers/base.py

@@ -1,335 +0,0 @@
-import logging
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any, Dict, Generator, List, Optional, Union
-
-from application.logging import build_stack_data
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ToolCall:
-    """Represents a tool/function call from the LLM."""
-
-    id: str
-    name: str
-    arguments: Union[str, Dict]
-    index: Optional[int] = None
-
-    @classmethod
-    def from_dict(cls, data: Dict) -> "ToolCall":
-        """Create ToolCall from dictionary."""
-        return cls(
-            id=data.get("id", ""),
-            name=data.get("name", ""),
-            arguments=data.get("arguments", {}),
-            index=data.get("index"),
-        )
-
-
-@dataclass
-class LLMResponse:
-    """Represents a response from the LLM."""
-
-    content: str
-    tool_calls: List[ToolCall]
-    finish_reason: str
-    raw_response: Any
-
-    @property
-    def requires_tool_call(self) -> bool:
-        """Check if the response requires tool calls."""
-        return bool(self.tool_calls) and self.finish_reason == "tool_calls"
-
-
-class LLMHandler(ABC):
-    """Abstract base class for LLM handlers."""
-
-    def __init__(self):
-        self.llm_calls = []
-        self.tool_calls = []
-
-    @abstractmethod
-    def parse_response(self, response: Any) -> LLMResponse:
-        """Parse raw LLM response into standardized format."""
-        pass
-
-    @abstractmethod
-    def create_tool_message(self, tool_call: ToolCall, result: Any) -> Dict:
-        """Create a tool result message for the conversation history."""
-        pass
-
-    @abstractmethod
-    def _iterate_stream(self, response: Any) -> Generator:
-        """Iterate through streaming response chunks."""
-        pass
-
-    def process_message_flow(
-        self,
-        agent,
-        initial_response,
-        tools_dict: Dict,
-        messages: List[Dict],
-        attachments: Optional[List] = None,
-        stream: bool = False,
-    ) -> Union[str, Generator]:
-        """
-        Main orchestration method for processing LLM message flow.
-
-        Args:
-            agent: The agent instance
-            initial_response: Initial LLM response
-            tools_dict: Dictionary of available tools
-            messages: Conversation history
-            attachments: Optional attachments
-            stream: Whether to use streaming
-
-        Returns:
-            Final response or generator for streaming
-        """
-        messages = self.prepare_messages(agent, messages, attachments)
-
-        if stream:
-            return self.handle_streaming(agent, initial_response, tools_dict, messages)
-        else:
-            return self.handle_non_streaming(
-                agent, initial_response, tools_dict, messages
-            )
-
-    def prepare_messages(
-        self, agent, messages: List[Dict], attachments: Optional[List] = None
-    ) -> List[Dict]:
-        """
-        Prepare messages with attachments and provider-specific formatting.
-
-        Args:
-            agent: The agent instance
-            messages: Original messages
-            attachments: List of attachments
-
-        Returns:
-            Prepared messages list
-        """
-        if not attachments:
-            return messages
-        logger.info(f"Preparing messages with {len(attachments)} attachments")
-        supported_types = agent.llm.get_supported_attachment_types()
-
-        supported_attachments = [
-            a for a in attachments if a.get("mime_type") in supported_types
-        ]
-        unsupported_attachments = [
-            a for a in attachments if a.get("mime_type") not in supported_types
-        ]
-
-        # Process supported attachments with the LLM's custom method
-
-        if supported_attachments:
-            logger.info(
-                f"Processing {len(supported_attachments)} supported attachments"
-            )
-            messages = agent.llm.prepare_messages_with_attachments(
-                messages, supported_attachments
-            )
-        # Process unsupported attachments with default method
-
-        if unsupported_attachments:
-            logger.info(
-                f"Processing {len(unsupported_attachments)} unsupported attachments"
-            )
-            messages = self._append_unsupported_attachments(
-                messages, unsupported_attachments
-            )
-        return messages
-
-    def _append_unsupported_attachments(
-        self, messages: List[Dict], attachments: List[Dict]
-    ) -> List[Dict]:
-        """
-        Default method to append unsupported attachment content to system prompt.
-
-        Args:
-            messages: Current messages
-            attachments: List of unsupported attachments
-
-        Returns:
-            Updated messages list
-        """
-        prepared_messages = messages.copy()
-        attachment_texts = []
-
-        for attachment in attachments:
-            logger.info(f"Adding attachment {attachment.get('id')} to context")
-            if "content" in attachment:
-                attachment_texts.append(
-                    f"Attached file content:\n\n{attachment['content']}"
-                )
-        if attachment_texts:
-            combined_text = "\n\n".join(attachment_texts)
-
-            system_msg = next(
-                (msg for msg in prepared_messages if msg.get("role") == "system"),
-                {"role": "system", "content": ""},
-            )
-
-            if system_msg not in prepared_messages:
-                prepared_messages.insert(0, system_msg)
-            system_msg["content"] += f"\n\n{combined_text}"
-        return prepared_messages
-
-    def handle_tool_calls(
-        self, agent, tool_calls: List[ToolCall], tools_dict: Dict, messages: List[Dict]
-    ) -> Generator:
-        """
-        Execute tool calls and update conversation history.
-
-        Args:
-            agent: The agent instance
-            tool_calls: List of tool calls to execute
-            tools_dict: Available tools dictionary
-            messages: Current conversation history
-
-        Returns:
-            Updated messages list
-        """
-        updated_messages = messages.copy()
-
-        for call in tool_calls:
-            try:
-                self.tool_calls.append(call)
-                tool_executor_gen = agent._execute_tool_action(tools_dict, call)
-                while True:
-                    try:
-                        yield next(tool_executor_gen)
-                    except StopIteration as e:
-                        tool_response, call_id = e.value
-                        break
-
-                updated_messages.append(
-                    {
-                        "role": "assistant",
-                        "content": [
-                            {
-                                "function_call": {
-                                    "name": call.name,
-                                    "args": call.arguments,
-                                    "call_id": call_id,
-                                }
-                            }
-                        ],
-                    }
-                )
-
-                updated_messages.append(self.create_tool_message(call, tool_response))
-
-            except Exception as e:
-                logger.error(f"Error executing tool: {str(e)}", exc_info=True)
-                updated_messages.append(
-                    {
-                        "role": "tool",
-                        "content": f"Error executing tool: {str(e)}",
-                        "tool_call_id": call.id,
-                    }
-                )
-
-        return updated_messages
-
-    def handle_non_streaming(
-        self, agent, response: Any, tools_dict: Dict, messages: List[Dict]
-    ) -> Generator:
-        """
-        Handle non-streaming response flow.
-
-        Args:
-            agent: The agent instance
-            response: Current LLM response
-            tools_dict: Available tools dictionary
-            messages: Conversation history
-
-        Returns:
-            Final response after processing all tool calls
-        """
-        parsed = self.parse_response(response)
-        self.llm_calls.append(build_stack_data(agent.llm))
-
-        while parsed.requires_tool_call:
-            tool_handler_gen = self.handle_tool_calls(
-                agent, parsed.tool_calls, tools_dict, messages
-            )
-            while True:
-                try:
-                    yield next(tool_handler_gen)
-                except StopIteration as e:
-                    messages = e.value
-                    break
-
-            response = agent.llm.gen(
-                model=agent.gpt_model, messages=messages, tools=agent.tools
-            )
-            parsed = self.parse_response(response)
-            self.llm_calls.append(build_stack_data(agent.llm))
-
-        return parsed.content
-
-    def handle_streaming(
-        self, agent, response: Any, tools_dict: Dict, messages: List[Dict]
-    ) -> Generator:
-        """
-        Handle streaming response flow.
-
-        Args:
-            agent: The agent instance
-            response: Current LLM response
-            tools_dict: Available tools dictionary
-            messages: Conversation history
-
-        Yields:
-            Streaming response chunks
-        """
-        buffer = ""
-        tool_calls = {}
-
-        for chunk in self._iterate_stream(response):
-            if isinstance(chunk, str):
-                yield chunk
-                continue
-            parsed = self.parse_response(chunk)
-
-            if parsed.tool_calls:
-                for call in parsed.tool_calls:
-                    if call.index not in tool_calls:
-                        tool_calls[call.index] = call
-                    else:
-                        existing = tool_calls[call.index]
-                        if call.id:
-                            existing.id = call.id
-                        if call.name:
-                            existing.name = call.name
-                        if call.arguments:
-                            existing.arguments += call.arguments
-            if parsed.finish_reason == "tool_calls":
-                tool_handler_gen = self.handle_tool_calls(
-                    agent, list(tool_calls.values()), tools_dict, messages
-                )
-                while True:
-                    try:
-                        yield next(tool_handler_gen)
-                    except StopIteration as e:
-                        messages = e.value
-                        break
-                tool_calls = {}
-
-                response = agent.llm.gen_stream(
-                    model=agent.gpt_model, messages=messages, tools=agent.tools
-                )
-                self.llm_calls.append(build_stack_data(agent.llm))
-
-                yield from self.handle_streaming(agent, response, tools_dict, messages)
-                return
-            if parsed.content:
-                buffer += parsed.content
-                yield buffer
-                buffer = ""
-            if parsed.finish_reason == "stop":
-                return

application/llm/handlers/google.py

@@ -1,78 +0,0 @@
-import uuid
-from typing import Any, Dict, Generator
-
-from application.llm.handlers.base import LLMHandler, LLMResponse, ToolCall
-
-
-class GoogleLLMHandler(LLMHandler):
-    """Handler for Google's GenAI API."""
-
-    def parse_response(self, response: Any) -> LLMResponse:
-        """Parse Google response into standardized format."""
-
-        if isinstance(response, str):
-            return LLMResponse(
-                content=response,
-                tool_calls=[],
-                finish_reason="stop",
-                raw_response=response,
-            )
-
-        if hasattr(response, "candidates"):
-            parts = response.candidates[0].content.parts if response.candidates else []
-            tool_calls = [
-                ToolCall(
-                    id=str(uuid.uuid4()),
-                    name=part.function_call.name,
-                    arguments=part.function_call.args,
-                )
-                for part in parts
-                if hasattr(part, "function_call") and part.function_call is not None
-            ]
-
-            content = " ".join(
-                part.text
-                for part in parts
-                if hasattr(part, "text") and part.text is not None
-            )
-            return LLMResponse(
-                content=content,
-                tool_calls=tool_calls,
-                finish_reason="tool_calls" if tool_calls else "stop",
-                raw_response=response,
-            )
-
-        else:
-            tool_calls = []
-            if hasattr(response, "function_call"):
-                tool_calls.append(
-                    ToolCall(
-                        id=str(uuid.uuid4()),
-                        name=response.function_call.name,
-                        arguments=response.function_call.args,
-                    )
-                )
-            return LLMResponse(
-                content=response.text if hasattr(response, "text") else "",
-                tool_calls=tool_calls,
-                finish_reason="tool_calls" if tool_calls else "stop",
-                raw_response=response,
-            )
-
-    def create_tool_message(self, tool_call: ToolCall, result: Any) -> Dict:
-        """Create Google-style tool message."""
-        from google.genai import types
-
-        return {
-            "role": "tool",
-            "content": [
-                types.Part.from_function_response(
-                    name=tool_call.name, response={"result": result}
-                ).to_json_dict()
-            ],
-        }
-
-    def _iterate_stream(self, response: Any) -> Generator:
-        """Iterate through Google streaming response."""
-        for chunk in response:
-            yield chunk

application/llm/handlers/handler_creator.py

@@ -1,18 +0,0 @@
-from application.llm.handlers.base import LLMHandler
-from application.llm.handlers.google import GoogleLLMHandler
-from application.llm.handlers.openai import OpenAILLMHandler
-
-
-class LLMHandlerCreator:
-    handlers = {
-        "openai": OpenAILLMHandler,
-        "google": GoogleLLMHandler,
-        "default": OpenAILLMHandler,
-    }
-
-    @classmethod
-    def create_handler(cls, llm_type: str, *args, **kwargs) -> LLMHandler:
-        handler_class = cls.handlers.get(llm_type.lower())
-        if not handler_class:
-            handler_class = OpenAILLMHandler
-        return handler_class(*args, **kwargs)

application/llm/handlers/openai.py

@@ -1,57 +0,0 @@
-from typing import Any, Dict, Generator
-
-from application.llm.handlers.base import LLMHandler, LLMResponse, ToolCall
-
-
-class OpenAILLMHandler(LLMHandler):
-    """Handler for OpenAI API."""
-
-    def parse_response(self, response: Any) -> LLMResponse:
-        """Parse OpenAI response into standardized format."""
-        if isinstance(response, str):
-            return LLMResponse(
-                content=response,
-                tool_calls=[],
-                finish_reason="stop",
-                raw_response=response,
-            )
-
-        message = getattr(response, "message", None) or getattr(response, "delta", None)
-
-        tool_calls = []
-        if hasattr(message, "tool_calls"):
-            tool_calls = [
-                ToolCall(
-                    id=getattr(tc, "id", ""),
-                    name=getattr(tc.function, "name", ""),
-                    arguments=getattr(tc.function, "arguments", ""),
-                    index=getattr(tc, "index", None),
-                )
-                for tc in message.tool_calls or []
-            ]
-        return LLMResponse(
-            content=getattr(message, "content", ""),
-            tool_calls=tool_calls,
-            finish_reason=getattr(response, "finish_reason", ""),
-            raw_response=response,
-        )
-
-    def create_tool_message(self, tool_call: ToolCall, result: Any) -> Dict:
-        """Create OpenAI-style tool message."""
-        return {
-            "role": "tool",
-            "content": [
-                {
-                    "function_response": {
-                        "name": tool_call.name,
-                        "response": {"result": result},
-                        "call_id": tool_call.id,
-                    }
-                }
-            ],
-        }
-
-    def _iterate_stream(self, response: Any) -> Generator:
-        """Iterate through OpenAI streaming response."""
-        for chunk in response:
-            yield chunk

application/llm/llama_cpp.py

@@ -2,7 +2,6 @@ from application.llm.base import BaseLLM
 from application.core.settings import settings
 import threading
 
-
 class LlamaSingleton:
     _instances = {}
     _lock = threading.Lock()  # Add a lock for thread synchronization
@@ -30,7 +29,7 @@ class LlamaCpp(BaseLLM):
         self,
         api_key=None,
         user_api_key=None,
-        llm_name=settings.LLM_PATH,
+        llm_name=settings.MODEL_PATH,
         *args,
         **kwargs,
     ):
@@ -43,18 +42,14 @@ class LlamaCpp(BaseLLM):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
         prompt = f"### Instruction \n {user_question} \n ### Context \n {context} \n ### Answer \n"
-        result = LlamaSingleton.query_model(
-            self.llama, prompt, max_tokens=150, echo=False
-        )
+        result = LlamaSingleton.query_model(self.llama, prompt, max_tokens=150, echo=False)
         return result["choices"][0]["text"].split("### Answer \n")[-1]
 
     def _raw_gen_stream(self, baseself, model, messages, stream=True, **kwargs):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
         prompt = f"### Instruction \n {user_question} \n ### Context \n {context} \n ### Answer \n"
-        result = LlamaSingleton.query_model(
-            self.llama, prompt, max_tokens=150, echo=False, stream=stream
-        )
+        result = LlamaSingleton.query_model(self.llama, prompt, max_tokens=150, echo=False, stream=stream)
         for item in result:
             for choice in item["choices"]:
-                yield choice["text"]
+                yield choice["text"]

application/llm/llm_creator.py

@@ -7,7 +7,6 @@ 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:
@@ -21,15 +20,12 @@ class LLMCreator:
         "docsgpt": DocsGPTAPILLM,
         "premai": PremAILLM,
         "groq": GroqLLM,
-        "google": GoogleLLM,
-        "novita": NovitaLLM,
+        "google": GoogleLLM
     }
 
     @classmethod
-    def create_llm(cls, type, api_key, user_api_key, decoded_token, *args, **kwargs):
+    def create_llm(cls, type, api_key, user_api_key, *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, decoded_token=decoded_token, *args, **kwargs
-        )
+        return llm_class(api_key, user_api_key, *args, **kwargs)

application/llm/novita.py

@@ -1,32 +0,0 @@
-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,10 +1,6 @@
-import base64
-import json
-import logging
-
-from application.core.settings import settings
 from application.llm.base import BaseLLM
-from application.storage.storage_creator import StorageCreator
+from application.core.settings import settings
+
 
 
 class OpenAILLM(BaseLLM):
@@ -13,101 +9,15 @@ class OpenAILLM(BaseLLM):
         from openai import OpenAI
 
         super().__init__(*args, **kwargs)
-        if (
-            isinstance(settings.OPENAI_BASE_URL, str)
-            and settings.OPENAI_BASE_URL.strip()
-        ):
-            self.client = OpenAI(api_key=api_key, base_url=settings.OPENAI_BASE_URL)
+        if settings.OPENAI_BASE_URL:
+            self.client = OpenAI(
+                api_key=api_key,
+                base_url=settings.OPENAI_BASE_URL
+            )
         else:
-            DEFAULT_OPENAI_API_BASE = "https://api.openai.com/v1"
-            self.client = OpenAI(api_key=api_key, base_url=DEFAULT_OPENAI_API_BASE)
+            self.client = OpenAI(api_key=api_key)
         self.api_key = api_key
         self.user_api_key = user_api_key
-        self.storage = StorageCreator.get_storage()
-
-    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"]
-                                    ),
-                                }
-                            )
-                        elif isinstance(item, dict):
-                            content_parts = []
-                            if "text" in item:
-                                content_parts.append(
-                                    {"type": "text", "text": item["text"]}
-                                )
-                            elif (
-                                "type" in item
-                                and item["type"] == "text"
-                                and "text" in item
-                            ):
-                                content_parts.append(item)
-                            elif (
-                                "type" in item
-                                and item["type"] == "file"
-                                and "file" in item
-                            ):
-                                content_parts.append(item)
-                            elif (
-                                "type" in item
-                                and item["type"] == "image_url"
-                                and "image_url" in item
-                            ):
-                                content_parts.append(item)
-                            cleaned_messages.append(
-                                {"role": role, "content": content_parts}
-                            )
-                        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,
@@ -115,32 +25,14 @@ class OpenAILLM(BaseLLM):
         model,
         messages,
         stream=False,
-        tools=None,
         engine=settings.AZURE_DEPLOYMENT_NAME,
-        response_format=None,
-        **kwargs,
-    ):
-        messages = self._clean_messages_openai(messages)
+        **kwargs
+    ):  
+        response = self.client.chat.completions.create(
+            model=model, messages=messages, stream=stream, **kwargs
+        )
 
-        request_params = {
-            "model": model,
-            "messages": messages,
-            "stream": stream,
-            **kwargs,
-        }
-
-        if tools:
-            request_params["tools"] = tools
-
-        if response_format:
-            request_params["response_format"] = response_format
-
-        response = self.client.chat.completions.create(**request_params)
-
-        if tools:
-            return response.choices[0]
-        else:
-            return response.choices[0].message.content
+        return response.choices[0].message.content
 
     def _raw_gen_stream(
         self,
@@ -148,276 +40,34 @@ class OpenAILLM(BaseLLM):
         model,
         messages,
         stream=True,
-        tools=None,
         engine=settings.AZURE_DEPLOYMENT_NAME,
-        response_format=None,
-        **kwargs,
-    ):
-        messages = self._clean_messages_openai(messages)
-
-        request_params = {
-            "model": model,
-            "messages": messages,
-            "stream": stream,
-            **kwargs,
-        }
-
-        if tools:
-            request_params["tools"] = tools
-
-        if response_format:
-            request_params["response_format"] = response_format
-
-        response = self.client.chat.completions.create(**request_params)
+        **kwargs
+    ):  
+        response = self.client.chat.completions.create(
+            model=model, 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
-            ):
+            # 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
-            elif len(line.choices) > 0:
-                yield line.choices[0]
-
-    def _supports_tools(self):
-        return True
-
-    def _supports_structured_output(self):
-        return True
-
-    def prepare_structured_output_format(self, json_schema):
-        if not json_schema:
-            return None
-
-        try:
-
-            def add_additional_properties_false(schema_obj):
-                if isinstance(schema_obj, dict):
-                    schema_copy = schema_obj.copy()
-
-                    if schema_copy.get("type") == "object":
-                        schema_copy["additionalProperties"] = False
-                        # Ensure 'required' includes all properties for OpenAI strict mode
-                        if "properties" in schema_copy:
-                            schema_copy["required"] = list(
-                                schema_copy["properties"].keys()
-                            )
-
-                    for key, value in schema_copy.items():
-                        if key == "properties" and isinstance(value, dict):
-                            schema_copy[key] = {
-                                prop_name: add_additional_properties_false(prop_schema)
-                                for prop_name, prop_schema in value.items()
-                            }
-                        elif key == "items" and isinstance(value, dict):
-                            schema_copy[key] = add_additional_properties_false(value)
-                        elif key in ["anyOf", "oneOf", "allOf"] and isinstance(
-                            value, list
-                        ):
-                            schema_copy[key] = [
-                                add_additional_properties_false(sub_schema)
-                                for sub_schema in value
-                            ]
-
-                    return schema_copy
-                return schema_obj
-
-            processed_schema = add_additional_properties_false(json_schema)
-
-            result = {
-                "type": "json_schema",
-                "json_schema": {
-                    "name": processed_schema.get("name", "response"),
-                    "description": processed_schema.get(
-                        "description", "Structured response"
-                    ),
-                    "schema": processed_schema,
-                    "strict": True,
-                },
-            }
-
-            return result
-
-        except Exception as e:
-            logging.error(f"Error preparing structured output format: {e}")
-            return None
-
-    def get_supported_attachment_types(self):
-        """
-        Return a list of MIME types supported by OpenAI for file uploads.
-
-        Returns:
-            list: List of supported MIME types
-        """
-        return [
-            "application/pdf",
-            "image/png",
-            "image/jpeg",
-            "image/jpg",
-            "image/webp",
-            "image/gif",
-        ]
-
-    def prepare_messages_with_attachments(self, messages, attachments=None):
-        """
-        Process attachments using OpenAI's file API for more efficient handling.
-
-        Args:
-            messages (list): List of message dictionaries.
-            attachments (list): List of attachment dictionaries with content and metadata.
-
-        Returns:
-            list: Messages formatted with file references for OpenAI API.
-        """
-        if not attachments:
-            return messages
-
-        prepared_messages = messages.copy()
-
-        # Find the user message to attach file_id to the last one
-        user_message_index = None
-        for i in range(len(prepared_messages) - 1, -1, -1):
-            if prepared_messages[i].get("role") == "user":
-                user_message_index = i
-                break
-
-        if user_message_index is None:
-            user_message = {"role": "user", "content": []}
-            prepared_messages.append(user_message)
-            user_message_index = len(prepared_messages) - 1
-
-        if isinstance(prepared_messages[user_message_index].get("content"), str):
-            text_content = prepared_messages[user_message_index]["content"]
-            prepared_messages[user_message_index]["content"] = [
-                {"type": "text", "text": text_content}
-            ]
-        elif not isinstance(prepared_messages[user_message_index].get("content"), list):
-            prepared_messages[user_message_index]["content"] = []
-
-        for attachment in attachments:
-            mime_type = attachment.get("mime_type")
-
-            if mime_type and mime_type.startswith("image/"):
-                try:
-                    base64_image = self._get_base64_image(attachment)
-                    prepared_messages[user_message_index]["content"].append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:{mime_type};base64,{base64_image}"
-                            },
-                        }
-                    )
-                except Exception as e:
-                    logging.error(
-                        f"Error processing image attachment: {e}", exc_info=True
-                    )
-                    if "content" in attachment:
-                        prepared_messages[user_message_index]["content"].append(
-                            {
-                                "type": "text",
-                                "text": f"[Image could not be processed: {attachment.get('path', 'unknown')}]",
-                            }
-                        )
-            # Handle PDFs using the file API
-            elif mime_type == "application/pdf":
-                try:
-                    file_id = self._upload_file_to_openai(attachment)
-                    prepared_messages[user_message_index]["content"].append(
-                        {"type": "file", "file": {"file_id": file_id}}
-                    )
-                except Exception as e:
-                    logging.error(f"Error uploading PDF to OpenAI: {e}", exc_info=True)
-                    if "content" in attachment:
-                        prepared_messages[user_message_index]["content"].append(
-                            {
-                                "type": "text",
-                                "text": f"File content:\n\n{attachment['content']}",
-                            }
-                        )
-
-        return prepared_messages
-
-    def _get_base64_image(self, attachment):
-        """
-        Convert an image file to base64 encoding.
-
-        Args:
-            attachment (dict): Attachment dictionary with path and metadata.
-
-        Returns:
-            str: Base64-encoded image data.
-        """
-        file_path = attachment.get("path")
-        if not file_path:
-            raise ValueError("No file path provided in attachment")
-
-        try:
-            with self.storage.get_file(file_path) as image_file:
-                return base64.b64encode(image_file.read()).decode("utf-8")
-        except FileNotFoundError:
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-    def _upload_file_to_openai(self, attachment):
-        """
-        Upload a file to OpenAI and return the file_id.
-
-        Args:
-            attachment (dict): Attachment dictionary with path and metadata.
-                Expected keys:
-                - path: Path to the file
-                - id: Optional MongoDB ID for caching
-
-        Returns:
-            str: OpenAI file_id for the uploaded file.
-        """
-        import logging
-
-        if "openai_file_id" in attachment:
-            return attachment["openai_file_id"]
-
-        file_path = attachment.get("path")
-
-        if not self.storage.file_exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        try:
-            file_id = self.storage.process_file(
-                file_path,
-                lambda local_path, **kwargs: self.client.files.create(
-                    file=open(local_path, "rb"), purpose="assistants"
-                ).id,
-            )
-
-            from application.core.mongo_db import MongoDB
-
-            mongo = MongoDB.get_client()
-            db = mongo[settings.MONGO_DB_NAME]
-            attachments_collection = db["attachments"]
-            if "_id" in attachment:
-                attachments_collection.update_one(
-                    {"_id": attachment["_id"]}, {"$set": {"openai_file_id": file_id}}
-                )
-
-            return file_id
-        except Exception as e:
-            logging.error(f"Error uploading file to OpenAI: {e}", exc_info=True)
-            raise
 
 
 class AzureOpenAILLM(OpenAILLM):
 
-    def __init__(self, api_key, user_api_key, *args, **kwargs):
-
-        super().__init__(api_key)
+    def __init__(
+        self, openai_api_key, openai_api_base, openai_api_version, deployment_name
+    ):
+        super().__init__(openai_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=api_key,
+            api_key=openai_api_key,
             api_version=settings.OPENAI_API_VERSION,
-            azure_endpoint=settings.OPENAI_API_BASE,
+            api_base=settings.OPENAI_API_BASE,
+            deployment_name=settings.AZURE_DEPLOYMENT_NAME,
         )

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, tools=None, **kwargs):
+    def _raw_gen(self, baseself, model, messages, stream=False, **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, tools=None, **kwargs):
+    def _raw_gen_stream(self, baseself, model, messages, stream=True, **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

@@ -1,161 +0,0 @@
-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
-from application.core.settings import settings
-
-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:
-    if obj is None:
-        raise ValueError("The 'obj' parameter cannot be None")
-    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()}
-        except AttributeError as e:
-            logging.warning(f"AttributeError while accessing {attr_name}: {e}")
-        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[settings.MONGO_DB_NAME]
-        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),
-        }
-        # clean up text fields to be no longer than 10000 characters
-        for key, value in log_entry.items():
-            if isinstance(value, str) and len(value) > 10000:
-                log_entry[key] = value[:10000]
-    
-        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}", exc_info=True)

application/parser/chunking.py

@@ -1,5 +1,5 @@
 import re
-from typing import List, Tuple
+from typing import List, Tuple, Union
 import logging
 from application.parser.schema.base import Document
 from application.utils import get_encoding
@@ -32,7 +32,16 @@ class Chunker:
             header, body = "", text  # No header, treat entire text as body
         return header, body
 
-
+    def combine_documents(self, doc: Document, next_doc: Document) -> Document:
+        combined_text = doc.text + " " + next_doc.text
+        combined_token_count = len(self.encoding.encode(combined_text))
+        new_doc = Document(
+            text=combined_text,
+            doc_id=doc.doc_id,
+            embedding=doc.embedding,
+            extra_info={**(doc.extra_info or {}), "token_count": combined_token_count}
+        )
+        return new_doc
     
     def split_document(self, doc: Document) -> List[Document]:
         split_docs = []
@@ -73,11 +82,26 @@ class Chunker:
                 processed_docs.append(doc)
                 i += 1
             elif token_count < self.min_tokens:
-  
-                doc.extra_info = doc.extra_info or {}
-                doc.extra_info["token_count"] = token_count
-                processed_docs.append(doc)
-                i += 1
+                if i + 1 < len(documents):
+                    next_doc = documents[i + 1]
+                    next_tokens = self.encoding.encode(next_doc.text)
+                    if token_count + len(next_tokens) <= self.max_tokens:
+                        # Combine small documents
+                        combined_doc = self.combine_documents(doc, next_doc)
+                        processed_docs.append(combined_doc)
+                        i += 2
+                    else:
+                        # Keep the small document as is if adding next_doc would exceed max_tokens
+                        doc.extra_info = doc.extra_info or {}
+                        doc.extra_info["token_count"] = token_count
+                        processed_docs.append(doc)
+                        i += 1
+                else:
+                    # No next document to combine with; add the small document as is
+                    doc.extra_info = doc.extra_info or {}
+                    doc.extra_info["token_count"] = token_count
+                    processed_docs.append(doc)
+                    i += 1
             else:
                 # Split large documents
                 processed_docs.extend(self.split_document(doc))

application/parser/connectors/__init__.py

@@ -1,18 +0,0 @@
-"""
-External knowledge base connectors for DocsGPT.
-
-This module contains connectors for external knowledge bases and document storage systems
-that require authentication and specialized handling, separate from simple web scrapers.
-"""
-
-from .base import BaseConnectorAuth, BaseConnectorLoader
-from .connector_creator import ConnectorCreator
-from .google_drive import GoogleDriveAuth, GoogleDriveLoader
-
-__all__ = [
-    'BaseConnectorAuth',
-    'BaseConnectorLoader',
-    'ConnectorCreator',
-    'GoogleDriveAuth',
-    'GoogleDriveLoader'
-]

application/parser/connectors/base.py

@@ -1,129 +0,0 @@
-"""
-Base classes for external knowledge base connectors.
-
-This module provides minimal abstract base classes that define the essential
-interface for external knowledge base connectors.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
-
-from application.parser.schema.base import Document
-
-
-class BaseConnectorAuth(ABC):
-    """
-    Abstract base class for connector authentication.
-    
-    Defines the minimal interface that all connector authentication
-    implementations must follow.
-    """
-    
-    @abstractmethod
-    def get_authorization_url(self, state: Optional[str] = None) -> str:
-        """
-        Generate authorization URL for OAuth flows.
-        
-        Args:
-            state: Optional state parameter for CSRF protection
-            
-        Returns:
-            Authorization URL
-        """
-        pass
-    
-    @abstractmethod
-    def exchange_code_for_tokens(self, authorization_code: str) -> Dict[str, Any]:
-        """
-        Exchange authorization code for access tokens.
-        
-        Args:
-            authorization_code: Authorization code from OAuth callback
-            
-        Returns:
-            Dictionary containing token information
-        """
-        pass
-    
-    @abstractmethod
-    def refresh_access_token(self, refresh_token: str) -> Dict[str, Any]:
-        """
-        Refresh an expired access token.
-        
-        Args:
-            refresh_token: Refresh token
-            
-        Returns:
-            Dictionary containing refreshed token information
-        """
-        pass
-    
-    @abstractmethod
-    def is_token_expired(self, token_info: Dict[str, Any]) -> bool:
-        """
-        Check if a token is expired.
-        
-        Args:
-            token_info: Token information dictionary
-            
-        Returns:
-            True if token is expired, False otherwise
-        """
-        pass
-
-
-class BaseConnectorLoader(ABC):
-    """
-    Abstract base class for connector loaders.
-    
-    Defines the minimal interface that all connector loader
-    implementations must follow.
-    """
-    
-    @abstractmethod
-    def __init__(self, session_token: str):
-        """
-        Initialize the connector loader.
-        
-        Args:
-            session_token: Authentication session token
-        """
-        pass
-    
-    @abstractmethod
-    def load_data(self, inputs: Dict[str, Any]) -> List[Document]:
-        """
-        Load documents from the external knowledge base.
-        
-        Args:
-            inputs: Configuration dictionary containing:
-                - file_ids: Optional list of specific file IDs to load
-                - folder_ids: Optional list of folder IDs to browse/download
-                - limit: Maximum number of items to return
-                - list_only: If True, return metadata without content
-                - recursive: Whether to recursively process folders
-                
-        Returns:
-            List of Document objects
-        """
-        pass
-    
-    @abstractmethod
-    def download_to_directory(self, local_dir: str, source_config: Dict[str, Any] = None) -> Dict[str, Any]:
-        """
-        Download files/folders to a local directory.
-        
-        Args:
-            local_dir: Local directory path to download files to
-            source_config: Configuration for what to download
-            
-        Returns:
-            Dictionary containing download results:
-                - files_downloaded: Number of files downloaded
-                - directory_path: Path where files were downloaded
-                - empty_result: Whether no files were downloaded
-                - source_type: Type of connector
-                - config_used: Configuration that was used
-                - error: Error message if download failed (optional)
-        """
-        pass

application/parser/connectors/connector_creator.py

@@ -1,81 +0,0 @@
-from application.parser.connectors.google_drive.loader import GoogleDriveLoader
-from application.parser.connectors.google_drive.auth import GoogleDriveAuth
-
-
-class ConnectorCreator:
-    """
-    Factory class for creating external knowledge base connectors and auth providers.
-
-    These are different from remote loaders as they typically require
-    authentication and connect to external document storage systems.
-    """
-
-    connectors = {
-        "google_drive": GoogleDriveLoader,
-    }
-
-    auth_providers = {
-        "google_drive": GoogleDriveAuth,
-    }
-
-    @classmethod
-    def create_connector(cls, connector_type, *args, **kwargs):
-        """
-        Create a connector instance for the specified type.
-
-        Args:
-            connector_type: Type of connector to create (e.g., 'google_drive')
-            *args, **kwargs: Arguments to pass to the connector constructor
-
-        Returns:
-            Connector instance
-
-        Raises:
-            ValueError: If connector type is not supported
-        """
-        connector_class = cls.connectors.get(connector_type.lower())
-        if not connector_class:
-            raise ValueError(f"No connector class found for type {connector_type}")
-        return connector_class(*args, **kwargs)
-
-    @classmethod
-    def create_auth(cls, connector_type):
-        """
-        Create an auth provider instance for the specified connector type.
-
-        Args:
-            connector_type: Type of connector auth to create (e.g., 'google_drive')
-
-        Returns:
-            Auth provider instance
-
-        Raises:
-            ValueError: If connector type is not supported for auth
-        """
-        auth_class = cls.auth_providers.get(connector_type.lower())
-        if not auth_class:
-            raise ValueError(f"No auth class found for type {connector_type}")
-        return auth_class()
-
-    @classmethod
-    def get_supported_connectors(cls):
-        """
-        Get list of supported connector types.
-
-        Returns:
-            List of supported connector type strings
-        """
-        return list(cls.connectors.keys())
-
-    @classmethod
-    def is_supported(cls, connector_type):
-        """
-        Check if a connector type is supported.
-
-        Args:
-            connector_type: Type of connector to check
-
-        Returns:
-            True if supported, False otherwise
-        """
-        return connector_type.lower() in cls.connectors

application/parser/connectors/google_drive/__init__.py

@@ -1,10 +0,0 @@
-"""
-Google Drive connector for DocsGPT.
-
-This module provides authentication and document loading capabilities for Google Drive.
-"""
-
-from .auth import GoogleDriveAuth
-from .loader import GoogleDriveLoader
-
-__all__ = ['GoogleDriveAuth', 'GoogleDriveLoader']

application/parser/connectors/google_drive/auth.py

@@ -1,268 +0,0 @@
-import logging
-import datetime
-from typing import Optional, Dict, Any
-
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import Flow
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-
-from application.core.settings import settings
-from application.parser.connectors.base import BaseConnectorAuth
-
-
-class GoogleDriveAuth(BaseConnectorAuth):
-    """
-    Handles Google OAuth 2.0 authentication for Google Drive access.
-    """
-    
-    SCOPES = [
-        'https://www.googleapis.com/auth/drive.readonly',
-        'https://www.googleapis.com/auth/drive.metadata.readonly'
-    ]
-    
-    def __init__(self):
-        self.client_id = settings.GOOGLE_CLIENT_ID
-        self.client_secret = settings.GOOGLE_CLIENT_SECRET
-        self.redirect_uri = f"{settings.CONNECTOR_REDIRECT_BASE_URI}?provider=google_drive"
-        
-        if not self.client_id or not self.client_secret:
-            raise ValueError("Google OAuth credentials not configured. Please set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET in settings.")
-
-
-
-    def get_authorization_url(self, state: Optional[str] = None) -> str:
-        try:
-            flow = Flow.from_client_config(
-                {
-                    "web": {
-                        "client_id": self.client_id,
-                        "client_secret": self.client_secret,
-                        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-                        "token_uri": "https://oauth2.googleapis.com/token",
-                        "redirect_uris": [self.redirect_uri]
-                    }
-                },
-                scopes=self.SCOPES
-            )
-            flow.redirect_uri = self.redirect_uri
-            
-            authorization_url, _ = flow.authorization_url(
-                access_type='offline',
-                prompt='consent',
-                include_granted_scopes='true',
-                state=state
-            )
-            
-            return authorization_url
-            
-        except Exception as e:
-            logging.error(f"Error generating authorization URL: {e}")
-            raise
-    
-    def exchange_code_for_tokens(self, authorization_code: str) -> Dict[str, Any]:
-        try:
-            if not authorization_code:
-                raise ValueError("Authorization code is required")
-
-            flow = Flow.from_client_config(
-                {
-                    "web": {
-                        "client_id": self.client_id,
-                        "client_secret": self.client_secret,
-                        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-                        "token_uri": "https://oauth2.googleapis.com/token",
-                        "redirect_uris": [self.redirect_uri]
-                    }
-                },
-                scopes=self.SCOPES
-            )
-            flow.redirect_uri = self.redirect_uri
-
-            flow.fetch_token(code=authorization_code)
-
-            credentials = flow.credentials
-
-            if not credentials.refresh_token:
-                logging.warning("OAuth flow did not return a refresh_token.")
-            if not credentials.token:
-                raise ValueError("OAuth flow did not return an access token")
-
-            if not credentials.token_uri:
-                credentials.token_uri = "https://oauth2.googleapis.com/token"
-
-            if not credentials.client_id:
-                credentials.client_id = self.client_id
-
-            if not credentials.client_secret:
-                credentials.client_secret = self.client_secret
-
-            if not credentials.refresh_token:
-                raise ValueError(
-                    "No refresh token received. This typically happens when offline access wasn't granted. "
-                )
-
-            return {
-                'access_token': credentials.token,
-                'refresh_token': credentials.refresh_token,
-                'token_uri': credentials.token_uri,
-                'client_id': credentials.client_id,
-                'client_secret': credentials.client_secret,
-                'scopes': credentials.scopes,
-                'expiry': credentials.expiry.isoformat() if credentials.expiry else None
-            }
-
-        except Exception as e:
-            logging.error(f"Error exchanging code for tokens: {e}")
-            raise
-    
-    def refresh_access_token(self, refresh_token: str) -> Dict[str, Any]:
-        try:
-            if not refresh_token:
-                raise ValueError("Refresh token is required")
-
-            credentials = Credentials(
-                token=None,
-                refresh_token=refresh_token,
-                token_uri="https://oauth2.googleapis.com/token",
-                client_id=self.client_id,
-                client_secret=self.client_secret
-            )
-
-            from google.auth.transport.requests import Request
-            credentials.refresh(Request())
-
-            return {
-                'access_token': credentials.token,
-                'refresh_token': refresh_token,
-                'token_uri': credentials.token_uri,
-                'client_id': credentials.client_id,
-                'client_secret': credentials.client_secret,
-                'scopes': credentials.scopes,
-                'expiry': credentials.expiry.isoformat() if credentials.expiry else None
-            }
-        except Exception as e:
-            logging.error(f"Error refreshing access token: {e}", exc_info=True)
-            raise
-    
-    def create_credentials_from_token_info(self, token_info: Dict[str, Any]) -> Credentials:
-        from application.core.settings import settings
-
-        access_token = token_info.get('access_token')
-        if not access_token:
-            raise ValueError("No access token found in token_info")
-
-        credentials = Credentials(
-            token=access_token,
-            refresh_token=token_info.get('refresh_token'),
-            token_uri= 'https://oauth2.googleapis.com/token',
-            client_id=settings.GOOGLE_CLIENT_ID,
-            client_secret=settings.GOOGLE_CLIENT_SECRET,
-            scopes=token_info.get('scopes', ['https://www.googleapis.com/auth/drive.readonly'])
-        )
-
-        if not credentials.token:
-            raise ValueError("Credentials created without valid access token")
-
-        return credentials
-    
-    def build_drive_service(self, credentials: Credentials):
-        try:
-            if not credentials:
-                raise ValueError("No credentials provided")
-
-            if not credentials.token and not credentials.refresh_token:
-                raise ValueError("No access token or refresh token available. User must re-authorize with offline access.")
-
-            needs_refresh = credentials.expired or not credentials.token
-            if needs_refresh:
-                if credentials.refresh_token:
-                    try:
-                        from google.auth.transport.requests import Request
-                        credentials.refresh(Request())
-                    except Exception as refresh_error:
-                        raise ValueError(f"Failed to refresh credentials: {refresh_error}")
-                else:
-                    raise ValueError("No access token or refresh token available. User must re-authorize with offline access.")
-
-            return build('drive', 'v3', credentials=credentials)
-
-        except HttpError as e:
-            raise ValueError(f"Failed to build Google Drive service: HTTP {e.resp.status}")
-        except Exception as e:
-            raise ValueError(f"Failed to build Google Drive service: {str(e)}")
-        
-    def is_token_expired(self, token_info):
-        if 'expiry' in token_info and token_info['expiry']:
-            try:
-                from dateutil import parser
-                # Google Drive provides timezone-aware ISO8601 dates
-                expiry_dt = parser.parse(token_info['expiry'])
-                current_time = datetime.datetime.now(datetime.timezone.utc)
-                return current_time >= expiry_dt - datetime.timedelta(seconds=60)
-            except Exception:
-                return True
-
-        if 'access_token' in token_info and token_info['access_token']:
-            return False
-
-        return True
-    
-    def get_token_info_from_session(self, session_token: str) -> Dict[str, Any]:
-        try:
-            from application.core.mongo_db import MongoDB
-            from application.core.settings import settings
-
-            mongo = MongoDB.get_client()
-            db = mongo[settings.MONGO_DB_NAME]
-            
-            sessions_collection = db["connector_sessions"]
-            session = sessions_collection.find_one({"session_token": session_token})   
-            if not session:
-                raise ValueError(f"Invalid session token: {session_token}")
-
-            if "token_info" not in session:
-                raise ValueError("Session missing token information")
-
-            token_info = session["token_info"]
-            if not token_info:
-                raise ValueError("Invalid token information")
-
-            required_fields = ["access_token", "refresh_token"]
-            missing_fields = [field for field in required_fields if field not in token_info or not token_info.get(field)]
-            if missing_fields:
-                raise ValueError(f"Missing required token fields: {missing_fields}")
-
-            if 'client_id' not in token_info:
-                token_info['client_id'] = settings.GOOGLE_CLIENT_ID
-            if 'client_secret' not in token_info:
-                token_info['client_secret'] = settings.GOOGLE_CLIENT_SECRET
-            if 'token_uri' not in token_info:
-                token_info['token_uri'] = 'https://oauth2.googleapis.com/token'
-
-            return token_info
-
-        except Exception as e:
-            raise ValueError(f"Failed to retrieve Google Drive token information: {str(e)}")
-
-    def validate_credentials(self, credentials: Credentials) -> bool:
-        """
-        Validate Google Drive credentials by making a test API call.
-
-        Args:
-            credentials: Google credentials object
-
-        Returns:
-            True if credentials are valid, False otherwise
-        """
-        try:
-            service = self.build_drive_service(credentials)
-            service.about().get(fields="user").execute()
-            return True
-
-        except HttpError as e:
-            logging.error(f"HTTP error validating credentials: {e}")
-            return False
-        except Exception as e:
-            logging.error(f"Error validating credentials: {e}")
-            return False

application/parser/connectors/google_drive/loader.py

@@ -1,536 +0,0 @@
-"""
-Google Drive loader for DocsGPT.
-Loads documents from Google Drive using Google Drive API.
-"""
-
-import io
-import logging
-import os
-from typing import List, Dict, Any, Optional
-
-from googleapiclient.http import MediaIoBaseDownload
-from googleapiclient.errors import HttpError
-
-from application.parser.connectors.base import BaseConnectorLoader
-from application.parser.connectors.google_drive.auth import GoogleDriveAuth
-from application.parser.schema.base import Document
-
-
-class GoogleDriveLoader(BaseConnectorLoader):
-
-    SUPPORTED_MIME_TYPES = {
-        'application/pdf': '.pdf',
-        'application/vnd.google-apps.document': '.docx',
-        'application/vnd.google-apps.presentation': '.pptx',
-        'application/vnd.google-apps.spreadsheet': '.xlsx',
-        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
-        'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',
-        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
-        'application/msword': '.doc',
-        'application/vnd.ms-powerpoint': '.ppt',
-        'application/vnd.ms-excel': '.xls',
-        'text/plain': '.txt',
-        'text/csv': '.csv',
-        'text/html': '.html',
-        'application/rtf': '.rtf',
-        'image/jpeg': '.jpg',
-        'image/jpg': '.jpg',
-        'image/png': '.png',
-    }
-
-    EXPORT_FORMATS = {
-        'application/vnd.google-apps.document': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        'application/vnd.google-apps.presentation': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-        'application/vnd.google-apps.spreadsheet': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-    }
-
-    def __init__(self, session_token: str):
-        self.auth = GoogleDriveAuth()
-        self.session_token = session_token
-
-        token_info = self.auth.get_token_info_from_session(session_token)
-        self.credentials = self.auth.create_credentials_from_token_info(token_info)
-
-        try:
-            self.service = self.auth.build_drive_service(self.credentials)
-        except Exception as e:
-            logging.warning(f"Could not build Google Drive service: {e}")
-            self.service = None
-
-        self.next_page_token = None
-
-
-
-    def _process_file(self, file_metadata: Dict[str, Any], load_content: bool = True) -> Optional[Document]:
-        try:
-            file_id = file_metadata.get('id')
-            file_name = file_metadata.get('name', 'Unknown')
-            mime_type = file_metadata.get('mimeType', 'application/octet-stream')
-
-            if mime_type not in self.SUPPORTED_MIME_TYPES and not mime_type.startswith('application/vnd.google-apps.'):
-                return None
-            if mime_type not in self.SUPPORTED_MIME_TYPES and not mime_type.startswith('application/vnd.google-apps.'):
-                logging.info(f"Skipping unsupported file type: {mime_type} for file {file_name}")
-                return None
-            # Google Drive provides timezone-aware ISO8601 dates
-            doc_metadata = {
-                'file_name': file_name,
-                'mime_type': mime_type,
-                'size': file_metadata.get('size', None),
-                'created_time': file_metadata.get('createdTime'),
-                'modified_time': file_metadata.get('modifiedTime'),
-                'parents': file_metadata.get('parents', []),
-                'source': 'google_drive'
-            }
-
-            if not load_content:
-                return Document(
-                    text="",
-                    doc_id=file_id,
-                    extra_info=doc_metadata
-                )
-
-            content = self._download_file_content(file_id, mime_type)
-            if content is None:
-                logging.warning(f"Could not load content for file {file_name} ({file_id})")
-                return None
-
-            return Document(
-                text=content,
-                doc_id=file_id,
-                extra_info=doc_metadata
-            )
-
-        except Exception as e:
-            logging.error(f"Error processing file: {e}")
-            return None
-
-    def load_data(self, inputs: Dict[str, Any]) -> List[Document]:
-        session_token = inputs.get('session_token')
-        if session_token and session_token != self.session_token:
-            logging.warning("Session token in inputs differs from loader's session token. Using loader's session token.")
-        self.config = inputs
-
-        try:
-            documents: List[Document] = []
-
-            folder_id = inputs.get('folder_id')
-            file_ids = inputs.get('file_ids', [])
-            limit = inputs.get('limit', 100)
-            list_only = inputs.get('list_only', False)
-            load_content = not list_only
-            page_token = inputs.get('page_token')
-            self.next_page_token = None
-
-            if file_ids:
-                # Specific files requested: load them
-                for file_id in file_ids:
-                    try:
-                        doc = self._load_file_by_id(file_id, load_content=load_content)
-                        if doc:
-                            documents.append(doc)
-                        elif hasattr(self, '_credential_refreshed') and self._credential_refreshed:
-                            self._credential_refreshed = False
-                            logging.info(f"Retrying load of file {file_id} after credential refresh")
-                            doc = self._load_file_by_id(file_id, load_content=load_content)
-                            if doc:
-                                documents.append(doc)
-                    except Exception as e:
-                        logging.error(f"Error loading file {file_id}: {e}")
-                        continue
-            else:
-                # Browsing mode: list immediate children of provided folder or root
-                parent_id = folder_id if folder_id else 'root'
-                documents = self._list_items_in_parent(parent_id, limit=limit, load_content=load_content, page_token=page_token)
-
-            logging.info(f"Loaded {len(documents)} documents from Google Drive")
-            return documents
-
-        except Exception as e:
-            logging.error(f"Error loading data from Google Drive: {e}", exc_info=True)
-            raise
-
-
-
-    def _load_file_by_id(self, file_id: str, load_content: bool = True) -> Optional[Document]:
-        self._ensure_service()
-
-        try:
-            file_metadata = self.service.files().get(
-                fileId=file_id,
-                fields='id,name,mimeType,size,createdTime,modifiedTime,parents'
-            ).execute()
-
-            return self._process_file(file_metadata, load_content=load_content)
-
-        except HttpError as e:
-            logging.error(f"HTTP error loading file {file_id}: {e.resp.status} - {e.content}")
-
-            if e.resp.status in [401, 403]:
-                if hasattr(self.credentials, 'refresh_token') and self.credentials.refresh_token:
-                    try:
-                        from google.auth.transport.requests import Request
-                        self.credentials.refresh(Request())
-                        self._ensure_service()
-                        return None
-                    except Exception as refresh_error:
-                        raise ValueError(f"Authentication failed and could not be refreshed: {refresh_error}")
-                else:
-                    raise ValueError("Authentication failed and cannot be refreshed: missing refresh_token")
-
-            return None
-        except Exception as e:
-            logging.error(f"Error loading file {file_id}: {e}")
-            return None
-
-
-    def _list_items_in_parent(self, parent_id: str, limit: int = 100, load_content: bool = False, page_token: Optional[str] = None) -> List[Document]:
-        self._ensure_service()
-
-        documents: List[Document] = []
-
-        try:
-            query = f"'{parent_id}' in parents and trashed=false"
-            next_token_out: Optional[str] = None
-
-            while True:
-                page_size = 100
-                if limit:
-                    remaining = max(0, limit - len(documents))
-                    if remaining == 0:
-                        break
-                    page_size = min(100, remaining)
-
-                results = self.service.files().list(
-                    q=query,
-                    fields='nextPageToken,files(id,name,mimeType,size,createdTime,modifiedTime,parents)',
-                    pageToken=page_token,
-                    pageSize=page_size
-                ).execute()
-
-                items = results.get('files', [])
-                for item in items:
-                    mime_type = item.get('mimeType')
-                    if mime_type == 'application/vnd.google-apps.folder':
-                        doc_metadata = {
-                            'file_name': item.get('name', 'Unknown'),
-                            'mime_type': mime_type,
-                            'size': item.get('size', None),
-                            'created_time': item.get('createdTime'),
-                            'modified_time': item.get('modifiedTime'),
-                            'parents': item.get('parents', []),
-                            'source': 'google_drive',
-                            'is_folder': True
-                        }
-                        documents.append(Document(text="", doc_id=item.get('id'), extra_info=doc_metadata))
-                    else:
-                        doc = self._process_file(item, load_content=load_content)
-                        if doc:
-                            documents.append(doc)
-
-                    if limit and len(documents) >= limit:
-                        self.next_page_token = results.get('nextPageToken')
-                        return documents
-
-                page_token = results.get('nextPageToken')
-                next_token_out = page_token
-                if not page_token:
-                    break
-
-            self.next_page_token = next_token_out
-            return documents
-        except Exception as e:
-            logging.error(f"Error listing items under parent {parent_id}: {e}")
-            return documents
-
-
-
-
-    def _download_file_content(self, file_id: str, mime_type: str) -> Optional[str]:
-        if not self.credentials.token:
-            logging.warning("No access token in credentials, attempting to refresh")
-            if hasattr(self.credentials, 'refresh_token') and self.credentials.refresh_token:
-                try:
-                    from google.auth.transport.requests import Request
-                    self.credentials.refresh(Request())
-                    logging.info("Credentials refreshed successfully")
-                    self._ensure_service()
-                except Exception as e:
-                    logging.error(f"Failed to refresh credentials: {e}")
-                    raise ValueError("Authentication failed and cannot be refreshed: missing or invalid refresh_token")
-            else:
-                logging.error("No access token and no refresh_token available")
-                raise ValueError("Authentication failed and cannot be refreshed: missing refresh_token")
-
-        if self.credentials.expired:
-            logging.warning("Credentials are expired, attempting to refresh")
-            if hasattr(self.credentials, 'refresh_token') and self.credentials.refresh_token:
-                try:
-                    from google.auth.transport.requests import Request
-                    self.credentials.refresh(Request())
-                    logging.info("Credentials refreshed successfully")
-                    self._ensure_service()
-                except Exception as e:
-                    logging.error(f"Failed to refresh expired credentials: {e}")
-                    raise ValueError("Authentication failed and cannot be refreshed: expired credentials")
-            else:
-                logging.error("Credentials expired and no refresh_token available")
-                raise ValueError("Authentication failed and cannot be refreshed: missing refresh_token")
-
-        try:
-            if mime_type in self.EXPORT_FORMATS:
-                export_mime_type = self.EXPORT_FORMATS[mime_type]
-                request = self.service.files().export_media(
-                    fileId=file_id,
-                    mimeType=export_mime_type
-                )
-            else:
-                request = self.service.files().get_media(fileId=file_id)
-
-            file_io = io.BytesIO()
-            downloader = MediaIoBaseDownload(file_io, request)
-
-            done = False
-            while done is False:
-                try:
-                    _, done = downloader.next_chunk()
-                except HttpError as e:
-                    logging.error(f"HTTP error downloading file {file_id}: {e.resp.status} - {e.content}")
-                    return None
-                except Exception as e:
-                    logging.error(f"Error during download of file {file_id}: {e}")
-                    return None
-
-            content_bytes = file_io.getvalue()
-
-            try:
-                content = content_bytes.decode('utf-8')
-            except UnicodeDecodeError:
-                try:
-                    content = content_bytes.decode('latin-1')
-                except UnicodeDecodeError:
-                    logging.error(f"Could not decode file {file_id} as text")
-                    return None
-
-            return content
-
-        except HttpError as e:
-            logging.error(f"HTTP error downloading file {file_id}: {e.resp.status} - {e.content}")
-
-            if e.resp.status in [401, 403]:
-                logging.error(f"Authentication error downloading file {file_id}")
-
-                if hasattr(self.credentials, 'refresh_token') and self.credentials.refresh_token:
-                    logging.info(f"Attempting to refresh credentials for file {file_id}")
-                    try:
-                        from google.auth.transport.requests import Request
-                        self.credentials.refresh(Request())
-                        logging.info("Credentials refreshed successfully")
-                        self._credential_refreshed = True
-                        self._ensure_service()
-                        return None
-                    except Exception as refresh_error:
-                        logging.error(f"Error refreshing credentials: {refresh_error}")
-                        raise ValueError(f"Authentication failed and could not be refreshed: {refresh_error}")
-                else:
-                    logging.error("Cannot refresh credentials: missing refresh_token")
-                    raise ValueError("Authentication failed and cannot be refreshed: missing refresh_token")
-
-            return None
-        except Exception as e:
-            logging.error(f"Error downloading file {file_id}: {e}")
-            return None
-
-
-    def _download_file_to_directory(self, file_id: str, local_dir: str) -> bool:
-        try:
-            self._ensure_service()
-            return self._download_single_file(file_id, local_dir)
-        except Exception as e:
-            logging.error(f"Error downloading file {file_id}: {e}", exc_info=True)
-            return False
-
-    def _ensure_service(self):
-        if not self.service:
-            try:
-                self.service = self.auth.build_drive_service(self.credentials)
-            except Exception as e:
-                raise ValueError(f"Cannot access Google Drive: {e}")
-
-    def _download_single_file(self, file_id: str, local_dir: str) -> bool:
-        file_metadata = self.service.files().get(
-            fileId=file_id,
-            fields='name,mimeType'
-        ).execute()
-
-        file_name = file_metadata['name']
-        mime_type = file_metadata['mimeType']
-
-        if mime_type not in self.SUPPORTED_MIME_TYPES and not mime_type.startswith('application/vnd.google-apps.'):
-            return False
-
-        os.makedirs(local_dir, exist_ok=True)
-        full_path = os.path.join(local_dir, file_name)
-
-        if mime_type in self.EXPORT_FORMATS:
-            export_mime_type = self.EXPORT_FORMATS[mime_type]
-            request = self.service.files().export_media(
-                fileId=file_id,
-                mimeType=export_mime_type
-            )
-            extension = self._get_extension_for_mime_type(export_mime_type)
-            if not full_path.endswith(extension):
-                full_path += extension
-        else:
-            request = self.service.files().get_media(fileId=file_id)
-
-        with open(full_path, 'wb') as f:
-            downloader = MediaIoBaseDownload(f, request)
-            done = False
-            while not done:
-                _, done = downloader.next_chunk()
-
-        return True
-
-    def _download_folder_recursive(self, folder_id: str, local_dir: str, recursive: bool = True) -> int:
-        files_downloaded = 0
-        try:
-            os.makedirs(local_dir, exist_ok=True)
-
-            query = f"'{folder_id}' in parents and trashed=false"
-            page_token = None
-
-            while True:
-                results = self.service.files().list(
-                    q=query,
-                    fields='nextPageToken, files(id, name, mimeType)',
-                    pageToken=page_token,
-                    pageSize=1000
-                ).execute()
-
-                items = results.get('files', [])
-                logging.info(f"Found {len(items)} items in folder {folder_id}")
-
-                for item in items:
-                    item_name = item['name']
-                    item_id = item['id']
-                    mime_type = item['mimeType']
-
-                    if mime_type == 'application/vnd.google-apps.folder':
-                        if recursive:
-                            # Create subfolder and recurse
-                            subfolder_path = os.path.join(local_dir, item_name)
-                            os.makedirs(subfolder_path, exist_ok=True)
-                            subfolder_files = self._download_folder_recursive(
-                                item_id,
-                                subfolder_path,
-                                recursive
-                            )
-                            files_downloaded += subfolder_files
-                            logging.info(f"Downloaded {subfolder_files} files from subfolder {item_name}")
-                    else:
-                        # Download file
-                        success = self._download_single_file(item_id, local_dir)
-                        if success:
-                            files_downloaded += 1
-                            logging.info(f"Downloaded file: {item_name}")
-                        else:
-                            logging.warning(f"Failed to download file: {item_name}")
-
-                page_token = results.get('nextPageToken')
-                if not page_token:
-                    break
-
-            return files_downloaded
-
-        except Exception as e:
-            logging.error(f"Error in _download_folder_recursive for folder {folder_id}: {e}", exc_info=True)
-            return files_downloaded
-
-    def _get_extension_for_mime_type(self, mime_type: str) -> str:
-        extensions = {
-            'application/pdf': '.pdf',
-            'text/plain': '.txt',
-            'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
-            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
-            'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',
-            'text/html': '.html',
-            'text/markdown': '.md',
-        }
-        return extensions.get(mime_type, '.bin')
-
-    def _download_folder_contents(self, folder_id: str, local_dir: str, recursive: bool = True) -> int:
-        try:
-            self._ensure_service()
-            return self._download_folder_recursive(folder_id, local_dir, recursive)
-        except Exception as e:
-            logging.error(f"Error downloading folder {folder_id}: {e}", exc_info=True)
-            return 0
-
-    def download_to_directory(self, local_dir: str, source_config: dict = None) -> dict:
-        if source_config is None:
-            source_config = {}
-
-        config = source_config if source_config else getattr(self, 'config', {})
-        files_downloaded = 0
-
-        try:
-            folder_ids = config.get('folder_ids', [])
-            file_ids = config.get('file_ids', [])
-            recursive = config.get('recursive', True)
-
-            self._ensure_service()
-
-            if file_ids:
-                if isinstance(file_ids, str):
-                    file_ids = [file_ids]
-
-                for file_id in file_ids:
-                    if self._download_file_to_directory(file_id, local_dir):
-                        files_downloaded += 1
-
-            # Process folders
-            if folder_ids:
-                if isinstance(folder_ids, str):
-                    folder_ids = [folder_ids]
-
-                for folder_id in folder_ids:
-                    try:
-                        folder_metadata = self.service.files().get(
-                            fileId=folder_id,
-                            fields='name'
-                        ).execute()
-                        folder_name = folder_metadata.get('name', '')
-                        folder_path = os.path.join(local_dir, folder_name)
-                        os.makedirs(folder_path, exist_ok=True)
-
-                        folder_files = self._download_folder_recursive(
-                            folder_id,
-                            folder_path,
-                            recursive
-                        )
-                        files_downloaded += folder_files
-                        logging.info(f"Downloaded {folder_files} files from folder {folder_name}")
-                    except Exception as e:
-                        logging.error(f"Error downloading folder {folder_id}: {e}", exc_info=True)
-
-            if not file_ids and not folder_ids:
-                raise ValueError("No folder_ids or file_ids provided for download")
-
-            return {
-                "files_downloaded": files_downloaded,
-                "directory_path": local_dir,
-                "empty_result": files_downloaded == 0,
-                "source_type": "google_drive",
-                "config_used": config
-            }
-
-        except Exception as e:
-            return {
-                "files_downloaded": files_downloaded,
-                "directory_path": local_dir,
-                "empty_result": True,
-                "source_type": "google_drive",
-                "config_used": config,
-                "error": str(e)
-            }

application/parser/embedding_pipeline.py

@@ -6,21 +6,6 @@ from application.core.settings import settings
 from application.vectorstore.vector_creator import VectorCreator
 
 
-def sanitize_content(content: str) -> str:
-    """
-    Remove NUL characters that can cause vector store ingestion to fail.
-    
-    Args:
-        content (str): Raw content that may contain NUL characters
-        
-    Returns:
-        str: Sanitized content with NUL characters removed
-    """
-    if not content:
-        return content
-    return content.replace('\x00', '')
-
-
 @retry(tries=10, delay=60)
 def add_text_to_store_with_retry(store, doc, source_id):
     """
@@ -31,13 +16,10 @@ def add_text_to_store_with_retry(store, doc, source_id):
         source_id: Unique identifier for the source.
     """
     try:
-        # Sanitize content to remove NUL characters that cause ingestion failures
-        doc.page_content = sanitize_content(doc.page_content)
-        
         doc.metadata["source_id"] = str(source_id)
         store.add_texts([doc.page_content], metadatas=[doc.metadata])
     except Exception as e:
-        logging.error(f"Failed to add document with retry: {e}", exc_info=True)
+        logging.error(f"Failed to add document with retry: {e}")
         raise
 
 
@@ -64,7 +46,7 @@ def embed_and_store_documents(docs, folder_name, source_id, task_status):
         store = VectorCreator.create_vectorstore(
             settings.VECTOR_STORE,
             docs_init=docs_init,
-            source_id=source_id,
+            source_id=folder_name,
             embeddings_key=os.getenv("EMBEDDINGS_KEY"),
         )
     else:
@@ -79,7 +61,7 @@ def embed_and_store_documents(docs, folder_name, source_id, task_status):
 
     # Process and embed documents
     for idx, doc in tqdm(
-        enumerate(docs),
+        docs,
         desc="Embedding 🦖",
         unit="docs",
         total=total_docs,
@@ -87,13 +69,13 @@ def embed_and_store_documents(docs, folder_name, source_id, task_status):
     ):
         try:
             # Update task status for progress tracking
-            progress = int(((idx + 1) / total_docs) * 100)
+            progress = int((idx / total_docs) * 100)
             task_status.update_state(state="PROGRESS", meta={"current": progress})
 
             # Add document to vector store
             add_text_to_store_with_retry(store, doc, source_id)
         except Exception as e:
-            logging.error(f"Error embedding document {idx}: {e}", exc_info=True)
+            logging.error(f"Error embedding document {idx}: {e}")
             logging.info(f"Saving progress at document {idx} out of {total_docs}")
             store.save_local(folder_name)
             break

application/parser/file/bulk.py

@@ -13,9 +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
-from application.utils import num_tokens_from_string
 
 DEFAULT_FILE_EXTRACTOR: Dict[str, BaseParser] = {
     ".pdf": PDFParser(),
@@ -29,9 +27,6 @@ DEFAULT_FILE_EXTRACTOR: Dict[str, BaseParser] = {
     ".mdx": MarkdownParser(),
     ".json":JSONParser(),
     ".pptx":PPTXParser(),
-    ".png": ImageParser(),
-    ".jpg": ImageParser(),
-    ".jpeg": ImageParser(),
 }
 
 
@@ -142,12 +137,11 @@ class SimpleDirectoryReader(BaseReader):
 
         Returns:
             List[Document]: A list of documents.
+
         """
         data: Union[str, List[str]] = ""
         data_list: List[str] = []
         metadata_list = []
-        self.file_token_counts = {}
-        
         for input_file in self.input_files:
             if input_file.suffix in self.file_extractor:
                 parser = self.file_extractor[input_file.suffix]
@@ -158,48 +152,24 @@ class SimpleDirectoryReader(BaseReader):
                 # do standard read
                 with open(input_file, "r", errors=self.errors) as f:
                     data = f.read()
-            
-            # Calculate token count for this file
-            if isinstance(data, List):
-                file_tokens = sum(num_tokens_from_string(str(d)) for d in data)
-            else:
-                file_tokens = num_tokens_from_string(str(data))
-            
-            full_path = str(input_file.resolve())
-            self.file_token_counts[full_path] = file_tokens
-            
-            base_metadata = {
-                'title': input_file.name,
-                'token_count': file_tokens,
-            }
-            
-            if hasattr(self, 'input_dir'):
-                try:
-                    relative_path = str(input_file.relative_to(self.input_dir))
-                    base_metadata['source'] = relative_path
-                except ValueError:
-                    base_metadata['source'] = str(input_file)
-            else:
-                base_metadata['source'] = str(input_file)
-
+            # Prepare metadata for this file
             if self.file_metadata is not None:
-                custom_metadata = self.file_metadata(input_file.name)
-                base_metadata.update(custom_metadata)
+                file_metadata = self.file_metadata(str(input_file))
+            else:
+                # Provide a default empty metadata
+                file_metadata = {'title': '', 'store': ''}
+                # TODO: Find a case with no metadata and check if breaks anything 
 
             if isinstance(data, List):
                 # Extend data_list with each item in the data list
                 data_list.extend([str(d) for d in data])
-                metadata_list.extend([base_metadata for _ in data])
+                # For each item in the data list, add the file's metadata to metadata_list
+                metadata_list.extend([file_metadata for _ in data])
             else:
+                # Add the single piece of data to data_list
                 data_list.append(str(data))
-                metadata_list.append(base_metadata)
-        
-        # Build directory structure if input_dir is provided
-        if hasattr(self, 'input_dir'):
-            self.directory_structure = self.build_directory_structure(self.input_dir)
-            logging.info("Directory structure built successfully")
-        else:
-            self.directory_structure = {}
+                # Add the file's metadata to metadata_list
+                metadata_list.append(file_metadata)
 
         if concatenate:
             return [Document("\n".join(data_list))]
@@ -207,48 +177,3 @@ class SimpleDirectoryReader(BaseReader):
             return [Document(d, extra_info=m) for d, m in zip(data_list, metadata_list)]
         else:
             return [Document(d) for d in data_list]
-
-    def build_directory_structure(self, base_path):
-        """Build a dictionary representing the directory structure.
-
-        Args:
-            base_path: The base path to start building the structure from.
-
-        Returns:
-            dict: A nested dictionary representing the directory structure.
-        """
-        import mimetypes
-        
-        def build_tree(path):
-            """Helper function to recursively build the directory tree."""
-            result = {}
-            
-            for item in path.iterdir():
-                if self.exclude_hidden and item.name.startswith('.'):
-                    continue
-                    
-                if item.is_dir():
-                    subtree = build_tree(item)
-                    if subtree:
-                        result[item.name] = subtree
-                else:
-                    if self.required_exts is not None and item.suffix not in self.required_exts:
-                        continue
-                    
-                    full_path = str(item.resolve())
-                    file_size_bytes = item.stat().st_size
-                    mime_type = mimetypes.guess_type(item.name)[0] or "application/octet-stream"
-                    
-                    file_info = {
-                        "type": mime_type,
-                        "size_bytes": file_size_bytes
-                    }
-                    
-                    if hasattr(self, 'file_token_counts') and full_path in self.file_token_counts:
-                        file_info["token_count"] = self.file_token_counts[full_path]
-                        
-                    result[item.name] = file_info
-                    
-            return result
-        
-        return build_tree(Path(base_path))

application/parser/file/docs_parser.py

@@ -7,8 +7,7 @@ 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."""
@@ -19,32 +18,22 @@ 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:
-            from pypdf import PdfReader
+            import PyPDF2
         except ImportError:
-            raise ValueError("pypdf is required to read PDF files.")
+            raise ValueError("PyPDF2 is required to read PDF files.")
         text_list = []
         with open(file, "rb") as fp:
             # Create a PDF object
-            pdf = PdfReader(fp)
+            pdf = PyPDF2.PdfReader(fp)
 
             # Get the number of pages in the PDF document
             num_pages = len(pdf.pages)
 
             # Iterate over every page
-            for page_index in range(num_pages):
+            for page in range(num_pages):
                 # Extract the text from the page
-                page = pdf.pages[page_index]
-                page_text = page.extract_text()
+                page_text = pdf.pages[page].extract_text()
                 text_list.append(page_text)
         text = "\n".join(text_list)
 
@@ -67,4 +56,4 @@ class DocxParser(BaseParser):
 
         text = docx2txt.process(file)
 
-        return text
+        return text

application/parser/file/image_parser.py

@@ -1,31 +0,0 @@
-"""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
-from application.core.settings import settings
-
-
-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]]:
-        if settings.PARSE_IMAGE_REMOTE:
-            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"] 
-        else:
-            data = ""
-        return data

application/parser/file/rst_parser.py

@@ -91,25 +91,6 @@ 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)
@@ -155,7 +136,7 @@ class RstParser(BaseParser):
         return {}
 
     def parse_tups(
-            self, filepath: Path, errors: str = "ignore",max_tokens: Optional[int] = 1000
+            self, filepath: Path, errors: str = "ignore"
     ) -> List[Tuple[Optional[str], str]]:
         """Parse file into tuples."""
         with open(filepath, "r") as f:
@@ -175,15 +156,6 @@ 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/file/tabular_parser.py

@@ -73,13 +73,7 @@ class PandasCSVParser(BaseParser):
             for more information.
             Set to empty dict by default, this means pandas will try to figure
             out the separators, table head, etc. on its own.
-            
-        header_period (int): Controls how headers are included in output:
-            - 0: Headers only at the beginning
-            - 1: Headers in every row
-            - N > 1: Headers every N rows
-            
-        header_prefix (str): Prefix for header rows. Default is "HEADERS: ".
+
     """
 
     def __init__(
@@ -89,8 +83,6 @@ class PandasCSVParser(BaseParser):
             col_joiner: str = ", ",
             row_joiner: str = "\n",
             pandas_config: dict = {},
-            header_period: int = 20,
-            header_prefix: str = "HEADERS: ",
             **kwargs: Any
     ) -> None:
         """Init params."""
@@ -99,8 +91,6 @@ class PandasCSVParser(BaseParser):
         self._col_joiner = col_joiner
         self._row_joiner = row_joiner
         self._pandas_config = pandas_config
-        self._header_period = header_period
-        self._header_prefix = header_prefix
 
     def _init_parser(self) -> Dict:
         """Init parser."""
@@ -114,26 +104,15 @@ class PandasCSVParser(BaseParser):
             raise ValueError("pandas module is required to read CSV files.")
 
         df = pd.read_csv(file, **self._pandas_config)
-        headers = df.columns.tolist()
-        header_row = f"{self._header_prefix}{self._col_joiner.join(headers)}"
 
-        if not self._concat_rows:
-            return df.apply(
-                lambda row: (self._col_joiner).join(row.astype(str).tolist()), axis=1
-            ).tolist()
-        
-        text_list = []
-        if self._header_period != 1:
-            text_list.append(header_row)
-        
-        for i, row in df.iterrows():
-            if (self._header_period > 1 and i > 0 and i % self._header_period == 0):
-                text_list.append(header_row)
-            text_list.append(self._col_joiner.join(row.astype(str).tolist()))
-            if self._header_period == 1 and i < len(df) - 1:
-                text_list.append(header_row)
+        text_list = df.apply(
+            lambda row: (self._col_joiner).join(row.astype(str).tolist()), axis=1
+        ).tolist()
 
-        return self._row_joiner.join(text_list)
+        if self._concat_rows:
+            return (self._row_joiner).join(text_list)
+        else:
+            return text_list
 
 
 class ExcelParser(BaseParser):
@@ -159,13 +138,7 @@ class ExcelParser(BaseParser):
             for more information.
             Set to empty dict by default, this means pandas will try to figure
             out the table structure on its own.
-            
-        header_period (int): Controls how headers are included in output:
-            - 0: Headers only at the beginning (default)
-            - 1: Headers in every row
-            - N > 1: Headers every N rows
-            
-        header_prefix (str): Prefix for header rows. Default is "HEADERS: ".
+
     """
 
     def __init__(
@@ -175,8 +148,6 @@ class ExcelParser(BaseParser):
             col_joiner: str = ", ",
             row_joiner: str = "\n",
             pandas_config: dict = {},
-            header_period: int = 20,
-            header_prefix: str = "HEADERS: ",
             **kwargs: Any
     ) -> None:
         """Init params."""
@@ -185,8 +156,6 @@ class ExcelParser(BaseParser):
         self._col_joiner = col_joiner
         self._row_joiner = row_joiner
         self._pandas_config = pandas_config
-        self._header_period = header_period
-        self._header_prefix = header_prefix
 
     def _init_parser(self) -> Dict:
         """Init parser."""
@@ -200,22 +169,12 @@ class ExcelParser(BaseParser):
             raise ValueError("pandas module is required to read Excel files.")
 
         df = pd.read_excel(file, **self._pandas_config)
-        headers = df.columns.tolist()
-        header_row = f"{self._header_prefix}{self._col_joiner.join(headers)}"
-        
-        if not self._concat_rows:
-            return df.apply(
-                lambda row: (self._col_joiner).join(row.astype(str).tolist()), axis=1
-            ).tolist()
-        
-        text_list = []
-        if self._header_period != 1:
-            text_list.append(header_row)
 
-        for i, row in df.iterrows():
-            if (self._header_period > 1 and i > 0 and i % self._header_period == 0):
-                text_list.append(header_row)
-            text_list.append(self._col_joiner.join(row.astype(str).tolist()))
-            if self._header_period == 1 and i < len(df) - 1:
-                text_list.append(header_row)
-        return self._row_joiner.join(text_list)
+        text_list = df.apply(
+            lambda row: (self._col_joiner).join(row.astype(str).tolist()), axis=1
+        ).tolist()
+
+        if self._concat_rows:
+            return (self._row_joiner).join(text_list)
+        else:
+            return text_list

application/parser/late_chunking.py

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

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

@@ -1,18 +1,17 @@
-import logging
 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]
 
@@ -20,30 +19,25 @@ class CrawlerLoader(BaseRemote):
         if not urlparse(url).scheme:
             url = "http://" + url
 
-        visited_urls = set()
-        base_url = urlparse(url).scheme + "://" + urlparse(url).hostname
-        urls_to_visit = [url]
-        loaded_content = []
+        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
 
+        # Continue crawling until there are no more URLs to visit
         while urls_to_visit:
-            current_url = urls_to_visit.pop(0)
-            visited_urls.add(current_url)
+            current_url = urls_to_visit.pop(0)  # Get the next URL to visit
+            visited_urls.add(current_url)  # Mark the URL as visited
 
+            # Try to load and process the content from the current URL
             try:
-                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
-                        )
-                    )
+                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
             except Exception as e:
-                logging.error(f"Error processing URL {current_url}: {e}", exc_info=True)
+                # Print an error message if loading or processing fails and continue with the next URL
+                print(f"Error processing URL {current_url}: {e}")
                 continue
 
             # Parse the HTML content to extract all links
@@ -51,15 +45,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'])
+                if base_url in urljoin(current_url, a['href'])  # Ensure links are from the same domain
             ]
 
             # 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))
+            urls_to_visit = list(set(urls_to_visit))  # Remove duplicate URLs
 
             # 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 loaded_content  # Return the loaded content from all visited URLs

application/parser/remote/crawler_markdown.py

@@ -1,139 +0,0 @@
-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/remote_creator.py

@@ -6,16 +6,6 @@ from application.parser.remote.github_loader import GitHubLoader
 
 
 class RemoteCreator:
-    """
-    Factory class for creating remote content loaders.
-
-    These loaders fetch content from remote web sources like URLs,
-    sitemaps, web crawlers, social media platforms, etc.
-
-    For external knowledge base connectors (like Google Drive),
-    use ConnectorCreator instead.
-    """
-
     loaders = {
         "url": WebLoader,
         "sitemap": SitemapLoader,
@@ -28,5 +18,5 @@ class RemoteCreator:
     def create_loader(cls, type, *args, **kwargs):
         loader_class = cls.loaders.get(type.lower())
         if not loader_class:
-            raise ValueError(f"No loader class found for type {type}")
+            raise ValueError(f"No LLM class found for type {type}")
         return loader_class(*args, **kwargs)

application/parser/remote/sitemap_loader.py

@@ -1,4 +1,3 @@
-import logging
 import requests
 import re  # Import regular expression library
 import xml.etree.ElementTree as ET
@@ -33,7 +32,7 @@ class SitemapLoader(BaseRemote):
                 documents.extend(loader.load())
                 processed_urls += 1  # Increment the counter after processing each URL
             except Exception as e:
-                logging.error(f"Error processing URL {url}: {e}", exc_info=True)
+                print(f"Error processing URL {url}: {e}")
                 continue
 
         return documents

application/parser/remote/web_loader.py

@@ -1,8 +1,5 @@
-import logging
 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",
@@ -26,20 +23,10 @@ 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)
-                loaded_docs = loader.load()
-                for doc in loaded_docs:
-                    documents.append(
-                        Document(
-                            doc.page_content,
-                            extra_info=doc.metadata,
-                        )
-                    )
+                documents.extend(loader.load())
             except Exception as e:
-                logging.error(f"Error processing URL {url}: {e}", exc_info=True)
+                print(f"Error processing URL {url}: {e}")
                 continue
         return documents

application/parser/token_func.py

@@ -0,0 +1,79 @@
+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/prompts/chat_combine_creative.txt

@@ -1,15 +1,9 @@
-You are a helpful AI assistant, DocsGPT. You are proactive and helpful. Try to use tools, if they are available to you, 
-be proactive and fill in missing information.
-Users can Upload documents for your context as attachments or sources via UI using the Conversation input box.
-If appropriate, your answers can include code examples, formatted as follows:
+You are a DocsGPT, friendly and helpful AI assistant by Arc53 that provides help with documents. You give thorough answers with code examples if possible.
+Use the following pieces of context to help answer the users question. If its not relevant to the question, provide friendly responses.
+You have access to chat history, and can use it to help answer the question.
+When using code examples, use the following format:
 ```(language)
 (code)
 ```
-Users are also able to see charts and diagrams if you use them with valid mermaid syntax in your responses.
-Try to respond with mermaid charts if visualization helps with users queries.
-You effectively utilize chat history, ensuring relevant and tailored responses. 
-Try to use additional provided context if it's available, otherwise use your knowledge and tool capabilities.
-Allow yourself to be very creative and use your imagination.
 ----------------
-Possible additional context from uploaded sources:
 {summaries}

application/prompts/chat_combine_default.txt

@@ -1,14 +1,9 @@
-You are a helpful AI assistant, DocsGPT. You are proactive and helpful. Try to use tools, if they are available to you, 
-be proactive and fill in missing information.
-Users can Upload documents for your context as attachments or sources via UI using the Conversation input box.
+You are a helpful AI assistant, DocsGPT, specializing in document assistance, designed to offer detailed and informative responses. 
 If appropriate, your answers can include code examples, formatted as follows:
 ```(language)
 (code)
 ```
-Users are also able to see charts and diagrams if you use them with valid mermaid syntax in your responses.
-Try to respond with mermaid charts if visualization helps with users queries.
 You effectively utilize chat history, ensuring relevant and tailored responses. 
-Try to use additional provided context if it's available, otherwise use your knowledge and tool capabilities.
+If a question doesn't align with your context, you provide friendly and helpful replies.
 ----------------
-Possible additional context from uploaded sources:
 {summaries}

application/prompts/chat_combine_strict.txt

@@ -1,17 +1,13 @@
-You are a helpful AI assistant, DocsGPT. You are proactive and helpful. Try to use tools, if they are available to you, 
-be proactive and fill in missing information.
-Users can Upload documents for your context as attachments or sources via UI using the Conversation input box.
-If appropriate, your answers can include code examples, formatted as follows:
+You are an AI Assistant, DocsGPT, adept at offering document assistance. 
+Your expertise lies in providing answer on top of provided context. 
+You can leverage the chat history if needed.
+Answer the question based on the context below. 
+Keep the answer concise. Respond "Irrelevant context" if not sure about the answer.
+If question is not related to the context, respond "Irrelevant context".
+When using code examples, use the following format:
 ```(language)
 (code)
 ```
-Users are also able to see charts and diagrams if you use them with valid mermaid syntax in your responses.
-Try to respond with mermaid charts if visualization helps with users queries.
-You effectively utilize chat history, ensuring relevant and tailored responses. 
-Use context provided below or use available tools tool capabilities to answer user queries.
-If you dont have enough information from the context or tools, answer "I don't know" or "I don't have enough information".
-Never make up information or provide false information!
-Allow yourself to be very creative and use your imagination.
-----------------
-Context from uploaded sources:
-{summaries}
+ ----------------
+ Context:
+ {summaries}

application/prompts/react_final_prompt.txt

@@ -1,3 +0,0 @@
-Query: {query}
-Observations: {observations}
-Now, using the insights from the observations, formulate a well-structured and precise final answer.

application/prompts/react_planning_prompt.txt

@@ -1,13 +0,0 @@
-You are an AI assistant and talk like you're thinking out loud. Given the following query, outline a concise thought process that includes key steps and considerations necessary for effective analysis and response. Avoid pointwise formatting. The goal is to break down the query into manageable components without excessive detail, focusing on clarity and logical progression.
-
-Include the following elements in your thought and execution process:
-1. Identify the main objective of the query.
-2. Determine any relevant context or background information needed to understand the query.
-3. List potential approaches or methods to address the query.
-4. Highlight any critical factors or constraints that may influence the outcome.
-5. Plan with available tools to help you with the analysis but dont execute them. Tools will be executed by another AI.
-
-Query: {query}  
-Summaries: {summaries}
-Prompt: {prompt}
-Observations(potentially previous tool calls): {observations}

application/requirements.txt

@@ -1,88 +1,89 @@
-anthropic==0.49.0
-boto3==1.38.18
-beautifulsoup4==4.13.4
-celery==5.4.0
+anthropic==0.34.2
+boto3==1.34.153
+beautifulsoup4==4.12.3
+celery==5.3.6
 dataclasses-json==0.6.7
 docx2txt==0.8
-duckduckgo-search==7.5.2
+duckduckgo-search==6.3.0
 ebooklib==0.18
+elastic-transport==8.15.0
+elasticsearch==8.15.1
 escodegen==1.0.11
 esprima==4.0.1
 esutils==1.0.1
-Flask==3.1.1
-faiss-cpu==1.9.0.post1
+Flask==3.0.3
+faiss-cpu==1.8.0.post1
 flask-restx==1.3.0
-google-genai==1.3.0
-google-api-python-client==2.179.0
-google-auth-httplib2==0.2.0
-google-auth-oauthlib==1.2.2
-gTTS==2.5.4
+gTTS==2.3.2
 gunicorn==23.0.0
+html2text==2024.2.26
 javalang==0.13.0
-jinja2==3.1.6
-jiter==0.8.2
+jinja2==3.1.4
+jiter==0.5.0
 jmespath==1.0.1
 joblib==1.4.2
 jsonpatch==1.33
 jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-spec==0.2.4
+jsonschema-specifications==2023.7.1
 kombu==5.4.2
-langchain==0.3.20
-langchain-community==0.3.19
-langchain-core==0.3.59
-langchain-openai==0.3.16
-langchain-text-splitters==0.3.8
-langsmith==0.3.42
+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
 lazy-object-proxy==1.10.0
-lxml==5.3.1
-markupsafe==3.0.2
-marshmallow==3.26.1
+lxml==5.3.0
+markupsafe==2.1.5
+marshmallow==3.22.0
 mpmath==1.3.0
-multidict==6.4.3
+multidict==6.1.0
 mypy-extensions==1.0.0
-networkx==3.4.2
-numpy==2.2.1
-openai==1.78.1
-openapi3-parser==1.1.21
-orjson==3.10.14
-packaging==24.2
+networkx==3.3
+numpy==1.26.4
+openai==1.46.1
+openapi-schema-validator==0.6.2
+openapi-spec-validator==0.6.0
+openapi3-parser==1.1.18
+orjson==3.10.7
+packaging==24.1
 pandas==2.2.3
 openpyxl==3.1.5
-pathable==0.4.4
-pillow==11.1.0
-portalocker>=2.7.0,<3.0.0
+pathable==0.4.3
+pillow==10.4.0
+portalocker==2.10.1
 prance==23.6.21.0
-prompt-toolkit==3.0.51
-protobuf==5.29.3
-psycopg2-binary==2.9.10
+primp==0.6.3
+prompt-toolkit==3.0.47
+protobuf==5.28.2
 py==1.11.0
-pydantic==2.10.6
-pydantic-core==2.27.2
-pydantic-settings==2.7.1
-pymongo==4.11.3
-pypdf==5.5.0
+pydantic==2.9.2
+pydantic-core==2.23.4
+pydantic-settings==2.4.0
+pymongo==4.8.0
+pypdf2==3.0.1
 python-dateutil==2.9.0.post0
 python-dotenv==1.0.1
-python-jose==3.4.0
 python-pptx==1.0.2
-redis==5.2.1
-referencing>=0.28.0,<0.31.0
-regex==2024.11.6
+qdrant-client==1.11.0
+redis==5.0.1
+referencing==0.30.2
+regex==2024.9.11
 requests==2.32.3
 retry==0.9.2
-sentence-transformers==3.3.1
-tiktoken==0.8.0
-tokenizers==0.21.0
-torch==2.7.0
-tqdm==4.67.1
-transformers==4.51.3
+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
 typing-extensions==4.12.2
 typing-inspect==0.9.0
 tzdata==2024.2
-urllib3==2.3.0
+urllib3==2.2.3
 vine==5.1.0
 wcwidth==0.2.13
-werkzeug==3.1.3
-yarl==1.20.0
-markdownify==1.1.0
-tldextract==5.1.3
-websockets==14.1
+werkzeug==3.0.4
+yarl==1.11.1

application/retriever/brave_search.py

@@ -0,0 +1,114 @@
+import json
+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 BraveSearch
+
+
+class BraveRetSearch(BaseRetriever):
+
+    def __init__(
+        self,
+        question,
+        source,
+        chat_history,
+        prompt,
+        chunks=2,
+        token_limit=150,
+        gpt_model="docsgpt",
+        user_api_key=None,
+    ):
+        self.question = question
+        self.source = source
+        self.chat_history = chat_history
+        self.prompt = prompt
+        self.chunks = chunks
+        self.gpt_model = gpt_model
+        self.token_limit = (
+            token_limit
+            if token_limit
+            < settings.MODEL_TOKEN_LIMITS.get(
+                self.gpt_model, settings.DEFAULT_MAX_HISTORY
+            )
+            else settings.MODEL_TOKEN_LIMITS.get(
+                self.gpt_model, settings.DEFAULT_MAX_HISTORY
+            )
+        )
+        self.user_api_key = user_api_key
+
+    def _get_data(self):
+        if self.chunks == 0:
+            docs = []
+        else:
+            search = BraveSearch.from_api_key(
+                api_key=settings.BRAVE_SEARCH_API_KEY,
+                search_kwargs={"count": int(self.chunks)},
+            )
+            results = search.run(self.question)
+            results = json.loads(results)
+
+            docs = []
+            for i in results:
+                try:
+                    title = i["title"]
+                    link = i["link"]
+                    snippet = i["snippet"]
+                    docs.append({"text": snippet, "title": title, "link": link})
+                except IndexError:
+                    pass
+        if settings.LLM_NAME == "llama.cpp":
+            docs = [docs[0]]
+
+        return docs
+
+    def gen(self):
+        docs = self._get_data()
+
+        # 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):
+        return self._get_data()
+
+    def get_params(self):
+        return {
+            "question": self.question,
+            "source": self.source,
+            "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
+        }

application/retriever/classic_rag.py

@@ -1,85 +1,44 @@
-import logging
-from application.core.settings import settings
-from application.llm.llm_creator import LLMCreator
 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.utils import num_tokens_from_string
 
 
 class ClassicRAG(BaseRetriever):
+
     def __init__(
         self,
+        question,
         source,
-        chat_history=None,
-        prompt="",
+        chat_history,
+        prompt,
         chunks=2,
         token_limit=150,
         gpt_model="docsgpt",
         user_api_key=None,
-        llm_name=settings.LLM_PROVIDER,
-        api_key=settings.API_KEY,
-        decoded_token=None,
     ):
-        self.original_question = ""
-        self.chat_history = chat_history if chat_history is not None else []
+        self.question = question
+        self.vectorstore = source['active_docs'] if 'active_docs' in source else None
+        self.chat_history = chat_history
         self.prompt = prompt
         self.chunks = chunks
         self.gpt_model = gpt_model
         self.token_limit = (
             token_limit
             if token_limit
-            < settings.LLM_TOKEN_LIMITS.get(
+            < settings.MODEL_TOKEN_LIMITS.get(
                 self.gpt_model, settings.DEFAULT_MAX_HISTORY
             )
-            else settings.LLM_TOKEN_LIMITS.get(
+            else settings.MODEL_TOKEN_LIMITS.get(
                 self.gpt_model, settings.DEFAULT_MAX_HISTORY
             )
         )
         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.vectorstore = source["active_docs"] if "active_docs" in source else None
-        self.question = self._rephrase_query()
-        self.decoded_token = decoded_token
-
-    def _rephrase_query(self):
-        if (
-            not self.original_question
-            or not self.chat_history
-            or self.chat_history == []
-            or self.chunks == 0
-            or self.vectorstore is None
-        ):
-            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:
-            logging.error(f"Error rephrasing query: {e}", exc_info=True)
-            return self.original_question
 
     def _get_data(self):
-        if self.chunks == 0 or self.vectorstore is None:
+        if self.chunks == 0:
             docs = []
         else:
             docsearch = VectorCreator.create_vectorstore(
@@ -103,22 +62,52 @@ class ClassicRAG(BaseRetriever):
 
         return docs
 
-    def gen():
-        pass
+    def gen(self):
+        docs = self._get_data()
 
-    def search(self, query: str = ""):
-        if query:
-            self.original_question = query
-            self.question = self._rephrase_query()
+        # 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):
         return self._get_data()
-
+    
     def get_params(self):
         return {
-            "question": self.original_question,
-            "rephrased_question": self.question,
+            "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

@@ -0,0 +1,131 @@
+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
+
+
+class DuckDuckSearch(BaseRetriever):
+
+    def __init__(
+        self,
+        question,
+        source,
+        chat_history,
+        prompt,
+        chunks=2,
+        token_limit=150,
+        gpt_model="docsgpt",
+        user_api_key=None,
+    ):
+        self.question = question
+        self.source = source
+        self.chat_history = chat_history
+        self.prompt = prompt
+        self.chunks = chunks
+        self.gpt_model = gpt_model
+        self.token_limit = (
+            token_limit
+            if token_limit
+            < settings.MODEL_TOKEN_LIMITS.get(
+                self.gpt_model, settings.DEFAULT_MAX_HISTORY
+            )
+            else settings.MODEL_TOKEN_LIMITS.get(
+                self.gpt_model, settings.DEFAULT_MAX_HISTORY
+            )
+        )
+        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
+
+    def _get_data(self):
+        if self.chunks == 0:
+            docs = []
+        else:
+            wrapper = DuckDuckGoSearchAPIWrapper(max_results=self.chunks)
+            search = DuckDuckGoSearchResults(api_wrapper=wrapper)
+            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})
+                except IndexError:
+                    pass
+        if settings.LLM_NAME == "llama.cpp":
+            docs = [docs[0]]
+
+        return docs
+
+    def gen(self):
+        docs = self._get_data()
+
+        # 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):
+        return self._get_data()
+    
+    def get_params(self):
+        return {
+            "question": self.question,
+            "source": self.source,
+            "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
+        }

application/retriever/retriever_creator.py

@@ -1,16 +1,20 @@
 from application.retriever.classic_rag import ClassicRAG
+from application.retriever.duckduck_search import DuckDuckSearch
+from application.retriever.brave_search import BraveRetSearch
+
 
 
 class RetrieverCreator:
     retrievers = {
-        "classic": ClassicRAG,
-        "default": ClassicRAG,
+        'classic': ClassicRAG,
+        'duckduck_search': DuckDuckSearch,
+        'brave_search': BraveRetSearch,
+        'default': ClassicRAG
     }
 
     @classmethod
     def create_retriever(cls, type, *args, **kwargs):
-        retriever_type = (type or "default").lower()
-        retiever_class = cls.retrievers.get(retriever_type)
+        retiever_class = cls.retrievers.get(type.lower())
         if not retiever_class:
             raise ValueError(f"No retievers class found for type {type}")
-        return retiever_class(*args, **kwargs)
+        return retiever_class(*args, **kwargs)