feat: add background information field to room model

- Add background_information field to Room database table and model - Create database migration for the new field - Update API schemas (CreateRoom, UpdateRoom) to handle background_information - Integrate room context into AI summarization prompts - Add background_information field to frontend room form - Update TypeScript types from regenerated OpenAPI spec The background information will be used to provide context for AI-generated summaries, helping create more appropriate and relevant meeting summaries. 🤖 Generated with [opencode](https://opencode.ai) Co-Authored-By: opencode <noreply@opencode.ai>
2025-12-20 20:29:06 +00:00 · 2025-07-29 01:53:13 +00:00
324 changed files with 19459 additions and 31104 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,21 +1,19 @@
-<!--- Provide a general summary of your changes in the Title above -->
+## ⚠️ Insert the PR TITLE replacing this text ⚠️

-## Description
-<!--- Describe your changes in detail -->
+⚠️ Describe your PR replacing this text. Post screenshots or videos whenever possible. ⚠️

-## Related Issue
-<!--- This project only accepts pull requests related to open issues -->
-<!--- If suggesting a new feature or change, please discuss it in an issue first -->
-<!--- If fixing a bug, there should be an issue describing it with steps to reproduce -->
-<!--- Please link to the issue here: -->
+### Checklist

-## Motivation and Context
-<!--- Why is this change required? What problem does it solve? -->
-<!--- If it fixes an open issue, please link to the issue here. -->
+ - [ ] My branch is updated with main (mandatory)
+ - [ ] I wrote unit tests for this (if applies)
+ - [ ] I have included migrations and tested them locally (if applies)
+ - [ ] I have manually tested this feature locally

-## How Has This Been Tested?
-<!--- Please describe in detail how you tested your changes. -->
-<!--- Include details of your testing environment, and the tests you ran to -->
-<!--- see how your change affects other areas of the code, etc. -->
+> IMPORTANT: Remember that you are responsible for merging this PR after it's been reviewed, and once deployed
+> you should perform manual testing to make sure everything went smoothly.
+
+### Urgency
+
+ - [ ] Urgent (deploy ASAP)
+ - [ ] Non-urgent (deploying in next release is ok)

-## Screenshots (if appropriate):
--- a/.github/workflows/conventional_commit_pr.yml
+++ b/.github/workflows/conventional_commit_pr.yml
@@ -0,0 +1,19 @@
+name: Conventional commit PR
+
+on: [pull_request]
+
+jobs:
+  cog_check_job:
+    runs-on: ubuntu-latest
+    name: check conventional commit compliance
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          # pick the pr HEAD instead of the merge commit
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: Conventional commit check
+        uses: cocogitto/cocogitto-action@v3
+        with:
+          check-latest-tag-only: true
--- a/.github/workflows/db_migrations.yml
+++ b/.github/workflows/db_migrations.yml
@@ -2,8 +2,6 @@ name: Test Database Migrations

 on:
  push:
-    branches:
-      - main
    paths:
      - "server/migrations/**"
      - "server/reflector/db/**"
@@ -19,43 +17,10 @@ on:
 jobs:
  test-migrations:
    runs-on: ubuntu-latest
-    concurrency:
-      group: db-ubuntu-latest-${{ github.ref }}
-      cancel-in-progress: true
-    services:
-      postgres:
-        image: postgres:17
-        env:
-          POSTGRES_USER: reflector
-          POSTGRES_PASSWORD: reflector
-          POSTGRES_DB: reflector
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd pg_isready -h 127.0.0.1 -p 5432
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-
-    env:
-      DATABASE_URL: postgresql://reflector:reflector@localhost:5432/reflector

    steps:
      - uses: actions/checkout@v4

-      - name: Install PostgreSQL client
-        run: sudo apt-get update && sudo apt-get install -y postgresql-client | cat
-
-      - name: Wait for Postgres
-        run: |
-          for i in {1..30}; do
-            if pg_isready -h localhost -p 5432; then
-              echo "Postgres is ready"
-              break
-            fi
-            echo "Waiting for Postgres... ($i)" && sleep 1
-          done
-
      - name: Install uv
        uses: astral-sh/setup-uv@v3
        with:
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -8,30 +8,18 @@ env:
  ECR_REPOSITORY: reflector

 jobs:
-  build:
-    strategy:
-      matrix:
-        include:
-          - platform: linux/amd64
-            runner: linux-amd64
-            arch: amd64
-          - platform: linux/arm64
-            runner: linux-arm64
-            arch: arm64
-
-    runs-on: ${{ matrix.runner }}
+  deploy:
+    runs-on: ubuntu-latest

    permissions:
+      deployments: write
      contents: read

-    outputs:
-      registry: ${{ steps.login-ecr.outputs.registry }}
-
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3

      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
@@ -39,52 +27,21 @@ jobs:

      - name: Login to Amazon ECR
        id: login-ecr
-        uses: aws-actions/amazon-ecr-login@v2
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2

-      - name: Build and push ${{ matrix.arch }}
-        uses: docker/build-push-action@v5
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v4
        with:
          context: server
-          platforms: ${{ matrix.platform }}
+          platforms: linux/amd64,linux/arm64
          push: true
-          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:latest-${{ matrix.arch }}
-          cache-from: type=gha,scope=${{ matrix.arch }}
-          cache-to: type=gha,mode=max,scope=${{ matrix.arch }}
-          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
-          provenance: false
-
-  create-manifest:
-    runs-on: ubuntu-latest
-    needs: [build]
-
-    permissions:
-      deployments: write
-      contents: read
-
-    steps:
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: ${{ env.AWS_REGION }}
-
-      - name: Login to Amazon ECR
-        uses: aws-actions/amazon-ecr-login@v2
-
-      - name: Create and push multi-arch manifest
-        run: |
-          # Get the registry URL (since we can't easily access job outputs in matrix)
-          ECR_REGISTRY=$(aws ecr describe-registry --query 'registryId' --output text).dkr.ecr.${{ env.AWS_REGION }}.amazonaws.com
-
-          docker manifest create \
-            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest \
-            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-amd64 \
-            $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest-arm64
-
-          docker manifest push $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest
-
-          echo "✅ Multi-arch manifest pushed: $ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:latest"
+          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -1,24 +0,0 @@
-name: pre-commit
-
-on:
-  pull_request:
-  push:
-    branches: [main]
-
-jobs:
-  pre-commit:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: actions/setup-python@v5
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 10
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: "pnpm"
-          cache-dependency-path: "www/pnpm-lock.yaml"
-      - name: Install dependencies
-        run: cd www && pnpm install --frozen-lockfile
-      - uses: pre-commit/action@v3.0.1
--- a/.github/workflows/test_next_server.yml
+++ b/.github/workflows/test_next_server.yml
@@ -1,45 +0,0 @@
-name: Test Next Server
-
-on:
-  pull_request:
-    paths:
-      - "www/**"
-  push:
-    branches:
-      - main
-    paths:
-      - "www/**"
-
-jobs:
-  test-next-server:
-    runs-on: ubuntu-latest
-
-    defaults:
-      run:
-        working-directory: ./www
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Setup Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: '20'
-
-    - name: Install pnpm
-      uses: pnpm/action-setup@v4
-      with:
-        version: 8
-
-    - name: Setup Node.js cache
-      uses: actions/setup-node@v4
-      with:
-        node-version: '20'
-        cache: 'pnpm'
-        cache-dependency-path: './www/pnpm-lock.yaml'
-
-    - name: Install dependencies
-      run: pnpm install
-
-    - name: Run tests
-      run: pnpm test
--- a/.github/workflows/test_server.yml
+++ b/.github/workflows/test_server.yml
@@ -5,17 +5,12 @@ on:
    paths:
      - "server/**"
  push:
-    branches:
-      - main
    paths:
      - "server/**"

 jobs:
  pytest:
    runs-on: ubuntu-latest
-    concurrency:
-      group: pytest-${{ github.ref }}
-      cancel-in-progress: true
    services:
      redis:
        image: redis:6
@@ -24,47 +19,29 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v3
        with:
          enable-cache: true
          working-directory: server
+
      - name: Tests
        run: |
          cd server
          uv run -m pytest -v tests

-  docker-amd64:
-    runs-on: linux-amd64
-    concurrency:
-      group: docker-amd64-${{ github.ref }}
-      cancel-in-progress: true
+  docker:
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Build AMD64
-        uses: docker/build-push-action@v6
+        uses: docker/setup-buildx-action@v2
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v4
        with:
          context: server
-          platforms: linux/amd64
-          cache-from: type=gha,scope=amd64
-          cache-to: type=gha,mode=max,scope=amd64
-          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
-
-  docker-arm64:
-    runs-on: linux-arm64
-    concurrency:
-      group: docker-arm64-${{ github.ref }}
-      cancel-in-progress: true
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Build ARM64
-        uses: docker/build-push-action@v6
-        with:
-          context: server
-          platforms: linux/arm64
-          cache-from: type=gha,scope=arm64
-          cache-to: type=gha,mode=max,scope=arm64
-          github-token: ${{ secrets.GHA_CACHE_TOKEN }}
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
--- a/.gitignore
+++ b/.gitignore
@@ -13,8 +13,3 @@ restart-dev.sh
 data/
 www/REFACTOR.md
 www/reload-frontend
-server/test.sqlite
-CLAUDE.local.md
-www/.env.development
-www/.env.production
-.playwright-mcp
--- a/.gitleaksignore
+++ b/.gitleaksignore
@@ -1 +0,0 @@
-b9d891d3424f371642cb032ecfd0e2564470a72c:server/tests/test_transcripts_recording_deletion.py:generic-api-key:15
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -3,10 +3,10 @@
 repos:
  - repo: local
    hooks:
-      - id: format
-        name: run format
+      - id: yarn-format
+        name: run yarn format
        language: system
-        entry: bash -c 'cd www && pnpm format'
+        entry: bash -c 'cd www && yarn format'
        pass_filenames: false
        files: ^www/

@@ -15,20 +15,25 @@ repos:
    hooks:
      - id: debug-statements
      - id: trailing-whitespace
+        exclude: ^server/trials
      - id: detect-private-key

+  - repo: https://github.com/psf/black
+    rev: 24.1.1
+    hooks:
+      - id: black
+        files: ^server/(reflector|tests)/
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: isort (python)
+        files: ^server/(gpu|evaluate|reflector)/
+        args: [ "--profile", "black", "--filter-files" ]
+
  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.2
+    rev: v0.6.5
    hooks:
      - id: ruff
-        args:
-          - --fix
-          # Uses select rules from server/pyproject.toml
-        files: ^server/
-      - id: ruff-format
-        files: ^server/
-
-  - repo: https://github.com/gitleaks/gitleaks
-    rev: v8.28.0
-    hooks:
-      - id: gitleaks
+        files: ^server/(reflector|tests)/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,145 +1,5 @@
 # Changelog

-## [0.10.0](https://github.com/Monadical-SAS/reflector/compare/v0.9.0...v0.10.0) (2025-09-11)
-
-
-### Features
-
-* replace nextjs-config with environment variables ([#632](https://github.com/Monadical-SAS/reflector/issues/632)) ([369ecdf](https://github.com/Monadical-SAS/reflector/commit/369ecdff13f3862d926a9c0b87df52c9d94c4dde))
-
-
-### Bug Fixes
-
-* anonymous users transcript permissions ([#621](https://github.com/Monadical-SAS/reflector/issues/621)) ([f81fe99](https://github.com/Monadical-SAS/reflector/commit/f81fe9948a9237b3e0001b2d8ca84f54d76878f9))
-* auth post ([#624](https://github.com/Monadical-SAS/reflector/issues/624)) ([cde99ca](https://github.com/Monadical-SAS/reflector/commit/cde99ca2716f84ba26798f289047732f0448742e))
-* auth post ([#626](https://github.com/Monadical-SAS/reflector/issues/626)) ([3b85ff3](https://github.com/Monadical-SAS/reflector/commit/3b85ff3bdf4fb053b103070646811bc990c0e70a))
-* auth post ([#627](https://github.com/Monadical-SAS/reflector/issues/627)) ([962038e](https://github.com/Monadical-SAS/reflector/commit/962038ee3f2a555dc3c03856be0e4409456e0996))
-* missing follow_redirects=True on modal endpoint ([#630](https://github.com/Monadical-SAS/reflector/issues/630)) ([fc363bd](https://github.com/Monadical-SAS/reflector/commit/fc363bd49b17b075e64f9186e5e0185abc325ea7))
-* sync backend and frontend token refresh logic ([#614](https://github.com/Monadical-SAS/reflector/issues/614)) ([5a5b323](https://github.com/Monadical-SAS/reflector/commit/5a5b3233820df9536da75e87ce6184a983d4713a))
-
-## [0.9.0](https://github.com/Monadical-SAS/reflector/compare/v0.8.2...v0.9.0) (2025-09-06)
-
-
-### Features
-
-* frontend openapi react query ([#606](https://github.com/Monadical-SAS/reflector/issues/606)) ([c4d2825](https://github.com/Monadical-SAS/reflector/commit/c4d2825c81f81ad8835629fbf6ea8c7383f8c31b))
-
-
-### Bug Fixes
-
-* align whisper transcriber api with parakeet ([#602](https://github.com/Monadical-SAS/reflector/issues/602)) ([0663700](https://github.com/Monadical-SAS/reflector/commit/0663700a615a4af69a03c96c410f049e23ec9443))
-* kv use tls explicit ([#610](https://github.com/Monadical-SAS/reflector/issues/610)) ([08d88ec](https://github.com/Monadical-SAS/reflector/commit/08d88ec349f38b0d13e0fa4cb73486c8dfd31836))
-* source kind for file processing ([#601](https://github.com/Monadical-SAS/reflector/issues/601)) ([dc82f8b](https://github.com/Monadical-SAS/reflector/commit/dc82f8bb3bdf3ab3d4088e592a30fd63907319e1))
-* token refresh locking ([#613](https://github.com/Monadical-SAS/reflector/issues/613)) ([7f5a4c9](https://github.com/Monadical-SAS/reflector/commit/7f5a4c9ddc7fd098860c8bdda2ca3b57f63ded2f))
-
-## [0.8.2](https://github.com/Monadical-SAS/reflector/compare/v0.8.1...v0.8.2) (2025-08-29)
-
-
-### Bug Fixes
-
-* search-logspam ([#593](https://github.com/Monadical-SAS/reflector/issues/593)) ([695d1a9](https://github.com/Monadical-SAS/reflector/commit/695d1a957d4cd862753049f9beed88836cabd5ab))
-
-## [0.8.1](https://github.com/Monadical-SAS/reflector/compare/v0.8.0...v0.8.1) (2025-08-29)
-
-
-### Bug Fixes
-
-* make webhook secret/url allowing null ([#590](https://github.com/Monadical-SAS/reflector/issues/590)) ([84a3812](https://github.com/Monadical-SAS/reflector/commit/84a381220bc606231d08d6f71d4babc818fa3c75))
-
-## [0.8.0](https://github.com/Monadical-SAS/reflector/compare/v0.7.3...v0.8.0) (2025-08-29)
-
-
-### Features
-
-* **cleanup:** add automatic data retention for public instances ([#574](https://github.com/Monadical-SAS/reflector/issues/574)) ([6f0c7c1](https://github.com/Monadical-SAS/reflector/commit/6f0c7c1a5e751713366886c8e764c2009e12ba72))
-* **rooms:** add webhook for transcript completion ([#578](https://github.com/Monadical-SAS/reflector/issues/578)) ([88ed7cf](https://github.com/Monadical-SAS/reflector/commit/88ed7cfa7804794b9b54cad4c3facc8a98cf85fd))
-
-
-### Bug Fixes
-
-* file pipeline status reporting and websocket updates ([#589](https://github.com/Monadical-SAS/reflector/issues/589)) ([9dfd769](https://github.com/Monadical-SAS/reflector/commit/9dfd76996f851cc52be54feea078adbc0816dc57))
-* Igor/evaluation ([#575](https://github.com/Monadical-SAS/reflector/issues/575)) ([124ce03](https://github.com/Monadical-SAS/reflector/commit/124ce03bf86044c18313d27228a25da4bc20c9c5))
-* optimize parakeet transcription batching algorithm ([#577](https://github.com/Monadical-SAS/reflector/issues/577)) ([7030e0f](https://github.com/Monadical-SAS/reflector/commit/7030e0f23649a8cf6c1eb6d5889684a41ce849ec))
-
-## [0.7.3](https://github.com/Monadical-SAS/reflector/compare/v0.7.2...v0.7.3) (2025-08-22)
-
-
-### Bug Fixes
-
-* cleaned repo, and get git-leaks clean ([359280d](https://github.com/Monadical-SAS/reflector/commit/359280dd340433ba4402ed69034094884c825e67))
-* restore previous behavior on live pipeline + audio downscaler ([#561](https://github.com/Monadical-SAS/reflector/issues/561)) ([9265d20](https://github.com/Monadical-SAS/reflector/commit/9265d201b590d23c628c5f19251b70f473859043))
-
-## [0.7.2](https://github.com/Monadical-SAS/reflector/compare/v0.7.1...v0.7.2) (2025-08-21)
-
-
-### Bug Fixes
-
-* docker image not loading libgomp.so.1 for torch ([#560](https://github.com/Monadical-SAS/reflector/issues/560)) ([773fccd](https://github.com/Monadical-SAS/reflector/commit/773fccd93e887c3493abc2e4a4864dddce610177))
-* include shared rooms to search ([#558](https://github.com/Monadical-SAS/reflector/issues/558)) ([499eced](https://github.com/Monadical-SAS/reflector/commit/499eced3360b84fb3a90e1c8a3b554290d21adc2))
-
-## [0.7.1](https://github.com/Monadical-SAS/reflector/compare/v0.7.0...v0.7.1) (2025-08-21)
-
-
-### Bug Fixes
-
-* webvtt db null expectation mismatch ([#556](https://github.com/Monadical-SAS/reflector/issues/556)) ([e67ad1a](https://github.com/Monadical-SAS/reflector/commit/e67ad1a4a2054467bfeb1e0258fbac5868aaaf21))
-
-## [0.7.0](https://github.com/Monadical-SAS/reflector/compare/v0.6.1...v0.7.0) (2025-08-21)
-
-
-### Features
-
-* delete recording with transcript ([#547](https://github.com/Monadical-SAS/reflector/issues/547)) ([99cc984](https://github.com/Monadical-SAS/reflector/commit/99cc9840b3f5de01e0adfbfae93234042d706d13))
-* pipeline improvement with file processing, parakeet, silero-vad ([#540](https://github.com/Monadical-SAS/reflector/issues/540)) ([bcc29c9](https://github.com/Monadical-SAS/reflector/commit/bcc29c9e0050ae215f89d460e9d645aaf6a5e486))
-* postgresql migration and removal of sqlite in pytest ([#546](https://github.com/Monadical-SAS/reflector/issues/546)) ([cd1990f](https://github.com/Monadical-SAS/reflector/commit/cd1990f8f0fe1503ef5069512f33777a73a93d7f))
-* search backend ([#537](https://github.com/Monadical-SAS/reflector/issues/537)) ([5f9b892](https://github.com/Monadical-SAS/reflector/commit/5f9b89260c9ef7f3c921319719467df22830453f))
-* search frontend  ([#551](https://github.com/Monadical-SAS/reflector/issues/551)) ([3657242](https://github.com/Monadical-SAS/reflector/commit/365724271ca6e615e3425125a69ae2b46ce39285))
-
-
-### Bug Fixes
-
-* evaluation cli event wrap ([#536](https://github.com/Monadical-SAS/reflector/issues/536)) ([941c3db](https://github.com/Monadical-SAS/reflector/commit/941c3db0bdacc7b61fea412f3746cc5a7cb67836))
-* use structlog not logging ([#550](https://github.com/Monadical-SAS/reflector/issues/550)) ([27e2f81](https://github.com/Monadical-SAS/reflector/commit/27e2f81fda5232e53edc729d3e99c5ef03adbfe9))
-
-## [0.6.1](https://github.com/Monadical-SAS/reflector/compare/v0.6.0...v0.6.1) (2025-08-06)
-
-
-### Bug Fixes
-
-* delayed waveform loading ([#538](https://github.com/Monadical-SAS/reflector/issues/538)) ([ef64146](https://github.com/Monadical-SAS/reflector/commit/ef64146325d03f64dd9a1fe40234fb3e7e957ae2))
-
-## [0.6.0](https://github.com/Monadical-SAS/reflector/compare/v0.5.0...v0.6.0) (2025-08-05)
-
-
-### ⚠ BREAKING CHANGES
-
-* Configuration keys have changed. Update your .env file:
-    - TRANSCRIPT_MODAL_API_KEY → TRANSCRIPT_API_KEY
-    - LLM_MODAL_API_KEY → (removed, use TRANSCRIPT_API_KEY)
-    - Add DIARIZATION_API_KEY and TRANSLATE_API_KEY if using those services
-
-### Features
-
-* implement service-specific Modal API keys with auto processor pattern ([#528](https://github.com/Monadical-SAS/reflector/issues/528)) ([650befb](https://github.com/Monadical-SAS/reflector/commit/650befb291c47a1f49e94a01ab37d8fdfcd2b65d))
-* use llamaindex everywhere ([#525](https://github.com/Monadical-SAS/reflector/issues/525)) ([3141d17](https://github.com/Monadical-SAS/reflector/commit/3141d172bc4d3b3d533370c8e6e351ea762169bf))
-
-
-### Miscellaneous Chores
-
-* **main:** release 0.6.0 ([ecdbf00](https://github.com/Monadical-SAS/reflector/commit/ecdbf003ea2476c3e95fd231adaeb852f2943df0))
-
-## [0.5.0](https://github.com/Monadical-SAS/reflector/compare/v0.4.0...v0.5.0) (2025-07-31)
-
-
-### Features
-
-* new summary using phi-4 and llama-index ([#519](https://github.com/Monadical-SAS/reflector/issues/519)) ([1bf9ce0](https://github.com/Monadical-SAS/reflector/commit/1bf9ce07c12f87f89e68a1dbb3b2c96c5ee62466))
-
-
-### Bug Fixes
-
-* remove unused settings and utils files ([#522](https://github.com/Monadical-SAS/reflector/issues/522)) ([2af4790](https://github.com/Monadical-SAS/reflector/commit/2af4790e4be9e588f282fbc1bb171c88a03d6479))
-
 ## [0.4.0](https://github.com/Monadical-SAS/reflector/compare/v0.3.2...v0.4.0) (2025-07-25)


--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -62,28 +62,29 @@ uv run python -m reflector.tools.process path/to/audio.wav
 **Setup:**
 ```bash
 # Install dependencies
-pnpm install
+yarn install

 # Copy configuration templates
 cp .env_template .env
+cp config-template.ts config.ts
 ```

 **Development:**
 ```bash
 # Start development server
-pnpm dev
+yarn dev

 # Generate TypeScript API client from OpenAPI spec
-pnpm openapi
+yarn openapi

 # Lint code
-pnpm lint
+yarn lint

 # Format code
-pnpm format
+yarn format

 # Build for production
-pnpm build
+yarn build
 ```

 ### Docker Compose (Full Stack)
@@ -143,9 +144,7 @@ All endpoints prefixed `/v1/`:
 **Backend** (`server/.env`):
 - `DATABASE_URL` - Database connection string
 - `REDIS_URL` - Redis broker for Celery
- `TRANSCRIPT_BACKEND=modal` + `TRANSCRIPT_MODAL_API_KEY` - Modal.com transcription
- `DIARIZATION_BACKEND=modal` + `DIARIZATION_MODAL_API_KEY` - Modal.com diarization
- `TRANSLATION_BACKEND=modal` + `TRANSLATION_MODAL_API_KEY` - Modal.com translation
+- `MODAL_TOKEN_ID`, `MODAL_TOKEN_SECRET` - Modal.com GPU processing
 - `WHEREBY_API_KEY` - Video platform integration
 - `REFLECTOR_AUTH_BACKEND` - Authentication method (none, jwt)

@@ -173,7 +172,3 @@ Modal.com integration for scalable ML processing:
 - **Audio Routing**: Use BlackHole (Mac) for merging multiple audio sources
 - **WebRTC**: Ensure proper CORS configuration for cross-origin streaming
 - **Database**: Run `uv run alembic upgrade head` after pulling schema changes
-
-## Pipeline/worker related info
-
-If you need to do any worker/pipeline related work, search for "Pipeline" classes and their "create" or "build" methods to find the main processor sequence. Look for task orchestration patterns (like "chord", "group", or "chain") to identify the post-processing flow with parallel execution chains. This will give you abstract vision on how processing pipeling is organized.
--- a/README.md
+++ b/README.md
@@ -1,60 +1,43 @@
 <div align="center">
-<img width="100" alt="image" src="https://github.com/user-attachments/assets/66fb367b-2c89-4516-9912-f47ac59c6a7f"/>

 # Reflector

-Reflector is an AI-powered audio transcription and meeting analysis platform that provides real-time transcription, speaker diarization, translation and summarization for audio content and live meetings. It works 100% with local models (whisper/parakeet, pyannote, seamless-m4t, and your local llm like phi-4).
+Reflector Audio Management and Analysis is a cutting-edge web application under development by Monadical. It utilizes AI to record meetings, providing a permanent record with transcripts, translations, and automated summaries.

-[![Tests](https://github.com/monadical-sas/reflector/actions/workflows/test_server.yml/badge.svg?branch=main&event=push)](https://github.com/monadical-sas/reflector/actions/workflows/test_server.yml)
-[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
-</div>
+[![Tests](https://github.com/monadical-sas/cubbi/actions/workflows/pytests.yml/badge.svg?branch=main&event=push)](https://github.com/monadical-sas/cubbi/actions/workflows/pytests.yml)
+[![License: MIT](https://img.shields.io/badge/license-AGPL--v3-green.svg)](https://opensource.org/licenses/AGPL-v3)
 </div>
+
+## Screenshots
 <table>
  <tr>
    <td>
-      <a href="https://github.com/user-attachments/assets/21f5597c-2930-4899-a154-f7bd61a59e97">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/21f5597c-2930-4899-a154-f7bd61a59e97" />
+      <a href="https://github.com/user-attachments/assets/3a976930-56c1-47ef-8c76-55d3864309e3">
+        <img width="700" alt="image" src="https://github.com/user-attachments/assets/3a976930-56c1-47ef-8c76-55d3864309e3" />
      </a>
    </td>
    <td>
-      <a href="https://github.com/user-attachments/assets/f6b9399a-5e51-4bae-b807-59128d0a940c">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/f6b9399a-5e51-4bae-b807-59128d0a940c" />
+      <a href="https://github.com/user-attachments/assets/bfe3bde3-08af-4426-a9a1-11ad5cd63b33">
+        <img width="700" alt="image" src="https://github.com/user-attachments/assets/bfe3bde3-08af-4426-a9a1-11ad5cd63b33" />
      </a>
    </td>
    <td>
-      <a href="https://github.com/user-attachments/assets/a42ce460-c1fd-4489-a995-270516193897">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/a42ce460-c1fd-4489-a995-270516193897" />
-      </a>
-    </td>
-    <td>
-      <a href="https://github.com/user-attachments/assets/21929f6d-c309-42fe-9c11-f1299e50fbd4">
-        <img width="700" alt="image" src="https://github.com/user-attachments/assets/21929f6d-c309-42fe-9c11-f1299e50fbd4" />
+      <a href="https://github.com/user-attachments/assets/7b60c9d0-efe4-474f-a27b-ea13bd0fabdc">
+        <img width="700" alt="image" src="https://github.com/user-attachments/assets/7b60c9d0-efe4-474f-a27b-ea13bd0fabdc" />
      </a>
    </td>
  </tr>
 </table>

-## What is Reflector?
-
-Reflector is a web application that utilizes local models to process audio content, providing:
-
- **Real-time Transcription**: Convert speech to text using [Whisper](https://github.com/openai/whisper) (multi-language) or [Parakeet](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v2) (English) models
- **Speaker Diarization**: Identify and label different speakers using [Pyannote](https://github.com/pyannote/pyannote-audio) 3.1
- **Live Translation**: Translate audio content in real-time to many languages with [Facebook Seamless-M4T](https://github.com/facebookresearch/seamless_communication)
- **Topic Detection & Summarization**: Extract key topics and generate concise summaries using LLMs
- **Meeting Recording**: Create permanent records of meetings with searchable transcripts
-
-Currently we provide [modal.com](https://modal.com/) gpu template to deploy.
-
 ## Background

 The project architecture consists of three primary components:

- **Back-End**: Python server that offers an API and data persistence, found in `server/`.
 - **Front-End**: NextJS React project hosted on Vercel, located in `www/`.
- **GPU implementation**: Providing services such as speech-to-text transcription, topic generation, automated summaries, and translations.
+- **Back-End**: Python server that offers an API and data persistence, found in `server/`.
+- **GPU implementation**: Providing services such as speech-to-text transcription, topic generation, automated summaries, and translations. Most reliable option is Modal deployment

-It also uses authentik for authentication if activated.
+It also uses authentik for authentication if activated, and Vercel for deployment and configuration of the front-end.

 ## Contribution Guidelines

@@ -89,25 +72,24 @@ Note: We currently do not have instructions for Windows users.

 ## Installation

-*Note: we're working toward better installation, theses instructions are not accurate for now*
-
 ### Frontend

-Start with `cd www`.
+Start with `cd backend`.

 **Installation**

 ```bash
-pnpm install
-cp .env.example .env
+yarn install
+cp .env_template .env
+cp config-template.ts config.ts
 ```

-Then, fill in the environment variables in `.env` as needed. If you are unsure on how to proceed, ask in Zulip.
+Then, fill in the environment variables in `.env` and the configuration in `config.ts` as needed. If you are unsure on how to proceed, ask in Zulip.

 **Run in development mode**

 ```bash
-pnpm dev
+yarn dev
 ```

 Then (after completing server setup and starting it) open [http://localhost:3000](http://localhost:3000) to view it in the browser.
@@ -117,7 +99,7 @@ Then (after completing server setup and starting it) open [http://localhost:3000
 To generate the TypeScript files from the openapi.json file, make sure the python server is running, then run:

 ```bash
-pnpm openapi
+yarn openapi
 ```

 ### Backend
@@ -167,34 +149,3 @@ You can manually process an audio file by calling the process tool:
 ```bash
 uv run python -m reflector.tools.process path/to/audio.wav
 ```
-
-
-## Feature Flags
-
-Reflector uses environment variable-based feature flags to control application functionality. These flags allow you to enable or disable features without code changes.
-
-### Available Feature Flags
-
-| Feature Flag | Environment Variable |
-|-------------|---------------------|
-| `requireLogin` | `NEXT_PUBLIC_FEATURE_REQUIRE_LOGIN` |
-| `privacy` | `NEXT_PUBLIC_FEATURE_PRIVACY` |
-| `browse` | `NEXT_PUBLIC_FEATURE_BROWSE` |
-| `sendToZulip` | `NEXT_PUBLIC_FEATURE_SEND_TO_ZULIP` |
-| `rooms` | `NEXT_PUBLIC_FEATURE_ROOMS` |
-
-### Setting Feature Flags
-
-Feature flags are controlled via environment variables using the pattern `NEXT_PUBLIC_FEATURE_{FEATURE_NAME}` where `{FEATURE_NAME}` is the SCREAMING_SNAKE_CASE version of the feature name.
-
-**Examples:**
-```bash
-# Enable user authentication requirement
-NEXT_PUBLIC_FEATURE_REQUIRE_LOGIN=true
-
-# Disable browse functionality
-NEXT_PUBLIC_FEATURE_BROWSE=false
-
-# Enable Zulip integration
-NEXT_PUBLIC_FEATURE_SEND_TO_ZULIP=true
-```
--- a/compose.yml
+++ b/compose.yml
@@ -6,7 +6,6 @@ services:
      - 1250:1250
    volumes:
      - ./server/:/app/
-      - /app/.venv
    env_file:
      - ./server/.env
    environment:
@@ -17,7 +16,6 @@ services:
      context: server
    volumes:
      - ./server/:/app/
-      - /app/.venv
    env_file:
      - ./server/.env
    environment:
@@ -28,7 +26,6 @@ services:
      context: server
    volumes:
      - ./server/:/app/
-      - /app/.venv
    env_file:
      - ./server/.env
    environment:
@@ -42,12 +39,11 @@ services:
    image: node:18
    ports:
      - "3000:3000"
-    command: sh -c "corepack enable && pnpm install && pnpm dev"
+    command: sh -c "yarn install && yarn dev"
    restart: unless-stopped
    working_dir: /app
    volumes:
      - ./www:/app/
-      - /app/node_modules
    env_file:
      - ./www/.env.local

--- a/server/.env_template
+++ b/server/.env_template
@@ -0,0 +1,16 @@
+TRANSCRIPT_BACKEND=modal
+TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-web.modal.run
+TRANSCRIPT_MODAL_API_KEY=***REMOVED***
+
+LLM_BACKEND=modal
+LLM_URL=https://monadical-sas--reflector-llm-web.modal.run
+LLM_MODAL_API_KEY=***REMOVED***
+
+TRANSLATE_URL=https://monadical-sas--reflector-translator-web.modal.run
+ZEPHYR_LLM_URL=https://monadical-sas--reflector-llm-zephyr-web.modal.run
+DIARIZATION_URL=https://monadical-sas--reflector-diarizer-web.modal.run
+
+BASE_URL=https://xxxxx.ngrok.app
+DIARIZATION_ENABLED=false
+
+SQS_POLLING_TIMEOUT_SECONDS=60
--- a/server/.gitignore
+++ b/server/.gitignore
@@ -176,8 +176,7 @@ artefacts/
 audio_*.wav

 # ignore local database
-*.sqlite3
-*.db
+reflector.sqlite3
 data/

 dump.rdb
--- a/server/Dockerfile
+++ b/server/Dockerfile
@@ -1,8 +1,7 @@
 FROM python:3.12-slim

 ENV PYTHONUNBUFFERED=1 \
-    UV_LINK_MODE=copy \
-    UV_NO_CACHE=1
+    UV_LINK_MODE=copy

 # builder install base dependencies
 WORKDIR /tmp
@@ -14,8 +13,8 @@ ENV PATH="/root/.local/bin/:$PATH"
 # install application dependencies
 RUN mkdir -p /app
 WORKDIR /app
-COPY pyproject.toml uv.lock README.md /app/
-RUN uv sync --compile-bytecode --locked
+COPY pyproject.toml uv.lock /app/
+RUN touch README.md && env uv sync --compile-bytecode --locked

 # pre-download nltk packages
 RUN uv run python -c "import nltk; nltk.download('punkt_tab'); nltk.download('averaged_perceptron_tagger_eng')"
@@ -27,15 +26,4 @@ COPY migrations /app/migrations
 COPY reflector /app/reflector
 WORKDIR /app

-# Create symlink for libgomp if it doesn't exist (for ARM64 compatibility)
-RUN if [ "$(uname -m)" = "aarch64" ] && [ ! -f /usr/lib/libgomp.so.1 ]; then \
-    LIBGOMP_PATH=$(find /app/.venv/lib -path "*/torch.libs/libgomp*.so.*" 2>/dev/null | head -n1); \
-    if [ -n "$LIBGOMP_PATH" ]; then \
-    ln -sf "$LIBGOMP_PATH" /usr/lib/libgomp.so.1; \
-    fi \
-    fi
-
-# Pre-check just to make sure the image will not fail
-RUN uv run python -c "import silero_vad.model"
-
 CMD ["./runserver.sh"]
--- a/server/README.md
+++ b/server/README.md
@@ -20,25 +20,3 @@ Polls SQS every 60 seconds via /server/reflector/worker/process.py:24-62:
 # Every 60 seconds, check for new recordings
 sqs = boto3.client("sqs", ...)
 response = sqs.receive_message(QueueUrl=queue_url, ...)
-
-# Requeue
-
-```bash
-uv run /app/requeue_uploaded_file.py TRANSCRIPT_ID
-```
-
-## Pipeline Management
-
-### Continue stuck pipeline from final summaries (identify_participants) step:
-
-```bash
-uv run python -c "from reflector.pipelines.main_live_pipeline import task_pipeline_final_summaries; result = task_pipeline_final_summaries.delay(transcript_id='TRANSCRIPT_ID'); print(f'Task queued: {result.id}')"
-```
-
-### Run full post-processing pipeline (continues to completion):
-
-```bash
-uv run python -c "from reflector.pipelines.main_live_pipeline import pipeline_post; pipeline_post(transcript_id='TRANSCRIPT_ID')"
-```
-
-.
--- a/server/docs/data_retention.md
+++ b/server/docs/data_retention.md
@@ -1,95 +0,0 @@
-# Data Retention and Cleanup
-
-## Overview
-
-For public instances of Reflector, a data retention policy is automatically enforced to delete anonymous user data after a configurable period (default: 7 days). This ensures compliance with privacy expectations and prevents unbounded storage growth.
-
-## Configuration
-
-### Environment Variables
-
- `PUBLIC_MODE` (bool): Must be set to `true` to enable automatic cleanup
- `PUBLIC_DATA_RETENTION_DAYS` (int): Number of days to retain anonymous data (default: 7)
-
-### What Gets Deleted
-
-When data reaches the retention period, the following items are automatically removed:
-
-1. **Transcripts** from anonymous users (where `user_id` is NULL):
-   - Database records
-   - Local files (audio.wav, audio.mp3, audio.json waveform)
-   - Storage files (cloud storage if configured)
-
-## Automatic Cleanup
-
-### Celery Beat Schedule
-
-When `PUBLIC_MODE=true`, a Celery beat task runs daily at 3 AM to clean up old data:
-
-```python
-# Automatically scheduled when PUBLIC_MODE=true
-"cleanup_old_public_data": {
-    "task": "reflector.worker.cleanup.cleanup_old_public_data",
-    "schedule": crontab(hour=3, minute=0),  # Daily at 3 AM
-}
-```
-
-### Running the Worker
-
-Ensure both Celery worker and beat scheduler are running:
-
-```bash
-# Start Celery worker
-uv run celery -A reflector.worker.app worker --loglevel=info
-
-# Start Celery beat scheduler (in another terminal)
-uv run celery -A reflector.worker.app beat
-```
-
-## Manual Cleanup
-
-For testing or manual intervention, use the cleanup tool:
-
-```bash
-# Delete data older than 7 days (default)
-uv run python -m reflector.tools.cleanup_old_data
-
-# Delete data older than 30 days
-uv run python -m reflector.tools.cleanup_old_data --days 30
-```
-
-Note: The manual tool uses the same implementation as the Celery worker task to ensure consistency.
-
-## Important Notes
-
-1. **User Data Deletion**: Only anonymous data (where `user_id` is NULL) is deleted. Authenticated user data is preserved.
-
-2. **Storage Cleanup**: The system properly cleans up both local files and cloud storage when configured.
-
-3. **Error Handling**: If individual deletions fail, the cleanup continues and logs errors. Failed deletions are reported in the task output.
-
-4. **Public Instance Only**: The automatic cleanup task only runs when `PUBLIC_MODE=true` to prevent accidental data loss in private deployments.
-
-## Testing
-
-Run the cleanup tests:
-
-```bash
-uv run pytest tests/test_cleanup.py -v
-```
-
-## Monitoring
-
-Check Celery logs for cleanup task execution:
-
-```bash
-# Look for cleanup task logs
-grep "cleanup_old_public_data" celery.log
-grep "Starting cleanup of old public data" celery.log
-```
-
-Task statistics are logged after each run:
- Number of transcripts deleted
- Number of meetings deleted
- Number of orphaned recordings deleted
- Any errors encountered
--- a/server/docs/gpu/api-transcription.md
+++ b/server/docs/gpu/api-transcription.md
@@ -1,194 +0,0 @@
-## Reflector GPU Transcription API (Specification)
-
-This document defines the Reflector GPU transcription API that all implementations must adhere to. Current implementations include NVIDIA Parakeet (NeMo) and Whisper (faster-whisper), both deployed on Modal.com. The API surface and response shapes are OpenAI/Whisper-compatible, so clients can switch implementations by changing only the base URL.
-
-### Base URL and Authentication
-
- Example base URLs (Modal web endpoints):
-
-  - Parakeet: `https://<account>--reflector-transcriber-parakeet-web.modal.run`
-  - Whisper: `https://<account>--reflector-transcriber-web.modal.run`
-
- All endpoints are served under `/v1` and require a Bearer token:
-
-```
-Authorization: Bearer <REFLECTOR_GPU_APIKEY>
-```
-
-Note: To switch implementations, deploy the desired variant and point `TRANSCRIPT_URL` to its base URL. The API is identical.
-
-### Supported file types
-
-`mp3, mp4, mpeg, mpga, m4a, wav, webm`
-
-### Models and languages
-
- Parakeet (NVIDIA NeMo): default `nvidia/parakeet-tdt-0.6b-v2`
-  - Language support: only `en`. Other languages return HTTP 400.
- Whisper (faster-whisper): default `large-v2` (or deployment-specific)
-  - Language support: multilingual (per Whisper model capabilities).
-
-Note: The `model` parameter is accepted by all implementations for interface parity. Some backends may treat it as informational.
-
-### Endpoints
-
-#### POST /v1/audio/transcriptions
-
-Transcribe one or more uploaded audio files.
-
-Request: multipart/form-data
-
- `file` (File) — optional. Single file to transcribe.
- `files` (File[]) — optional. One or more files to transcribe.
- `model` (string) — optional. Defaults to the implementation-specific model (see above).
- `language` (string) — optional, defaults to `en`.
-  - Parakeet: only `en` is accepted; other values return HTTP 400
-  - Whisper: model-dependent; typically multilingual
- `batch` (boolean) — optional, defaults to `false`.
-
-Notes:
-
- Provide either `file` or `files`, not both. If neither is provided, HTTP 400.
- `batch` requires `files`; using `batch=true` without `files` returns HTTP 400.
- Response shape for multiple files is the same regardless of `batch`.
- Files sent to this endpoint are processed in a single pass (no VAD/chunking). This is intended for short clips (roughly ≤ 30s; depends on GPU memory/model). For longer audio, prefer `/v1/audio/transcriptions-from-url` which supports VAD-based chunking.
-
-Responses
-
-Single file response:
-
-```json
-{
-  "text": "transcribed text",
-  "words": [
-    { "word": "hello", "start": 0.0, "end": 0.5 },
-    { "word": "world", "start": 0.5, "end": 1.0 }
-  ],
-  "filename": "audio.mp3"
-}
-```
-
-Multiple files response:
-
-```json
-{
-  "results": [
-    {"filename": "a1.mp3", "text": "...", "words": [...]},
-    {"filename": "a2.mp3", "text": "...", "words": [...]}]
-}
-```
-
-Notes:
-
- Word objects always include keys: `word`, `start`, `end`.
- Some implementations may include a trailing space in `word` to match Whisper tokenization behavior; clients should trim if needed.
-
-Example curl (single file):
-
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
-  -F "file=@/path/to/audio.mp3" \
-  -F "language=en" \
-  "$BASE_URL/v1/audio/transcriptions"
-```
-
-Example curl (multiple files, batch):
-
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
-  -F "files=@/path/a1.mp3" -F "files=@/path/a2.mp3" \
-  -F "batch=true" -F "language=en" \
-  "$BASE_URL/v1/audio/transcriptions"
-```
-
-#### POST /v1/audio/transcriptions-from-url
-
-Transcribe a single remote audio file by URL.
-
-Request: application/json
-
-Body parameters:
-
- `audio_file_url` (string) — required. URL of the audio file to transcribe.
- `model` (string) — optional. Defaults to the implementation-specific model (see above).
- `language` (string) — optional, defaults to `en`. Parakeet only accepts `en`.
- `timestamp_offset` (number) — optional, defaults to `0.0`. Added to each word's `start`/`end` in the response.
-
-```json
-{
-  "audio_file_url": "https://example.com/audio.mp3",
-  "model": "nvidia/parakeet-tdt-0.6b-v2",
-  "language": "en",
-  "timestamp_offset": 0.0
-}
-```
-
-Response:
-
-```json
-{
-  "text": "transcribed text",
-  "words": [
-    { "word": "hello", "start": 10.0, "end": 10.5 },
-    { "word": "world", "start": 10.5, "end": 11.0 }
-  ]
-}
-```
-
-Notes:
-
- `timestamp_offset` is added to each word’s `start`/`end` in the response.
- Implementations may perform VAD-based chunking and batching for long-form audio; word timings are adjusted accordingly.
-
-Example curl:
-
-```bash
-curl -X POST \
-  -H "Authorization: Bearer $REFLECTOR_GPU_APIKEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-        "audio_file_url": "https://example.com/audio.mp3",
-        "language": "en",
-        "timestamp_offset": 0
-      }' \
-  "$BASE_URL/v1/audio/transcriptions-from-url"
-```
-
-### Error handling
-
- 400 Bad Request
-  - Parakeet: `language` other than `en`
-  - Missing required parameters (`file`/`files` for upload; `audio_file_url` for URL endpoint)
-  - Unsupported file extension
- 401 Unauthorized
-  - Missing or invalid Bearer token
- 404 Not Found
-  - `audio_file_url` does not exist
-
-### Implementation details
-
- GPUs: A10G for small-file/live, L40S for large-file URL transcription (subject to deployment)
- VAD chunking and segment batching; word timings adjusted and overlapping ends constrained
- Pads very short segments (< 0.5s) to avoid model crashes on some backends
-
-### Server configuration (Reflector API)
-
-Set the Reflector server to use the Modal backend and point `TRANSCRIPT_URL` to your chosen deployment:
-
-```
-TRANSCRIPT_BACKEND=modal
-TRANSCRIPT_URL=https://<account>--reflector-transcriber-parakeet-web.modal.run
-TRANSCRIPT_MODAL_API_KEY=<REFLECTOR_GPU_APIKEY>
-```
-
-### Conformance tests
-
-Use the pytest-based conformance tests to validate any new implementation (including self-hosted) against this spec:
-
-```
-TRANSCRIPT_URL=https://<your-deployment-base> \
-TRANSCRIPT_MODAL_API_KEY=your-api-key \
-uv run -m pytest -m gpu_modal --no-cov server/tests/test_gpu_modal_transcript.py
-```
--- a/server/docs/webhook.md
+++ b/server/docs/webhook.md
@@ -1,212 +0,0 @@
-# Reflector Webhook Documentation
-
-## Overview
-
-Reflector supports webhook notifications to notify external systems when transcript processing is completed. Webhooks can be configured per room and are triggered automatically after a transcript is successfully processed.
-
-## Configuration
-
-Webhooks are configured at the room level with two fields:
- `webhook_url`: The HTTPS endpoint to receive webhook notifications
- `webhook_secret`: Optional secret key for HMAC signature verification (auto-generated if not provided)
-
-## Events
-
-### `transcript.completed`
-
-Triggered when a transcript has been fully processed, including transcription, diarization, summarization, and topic detection.
-
-### `test`
-
-A test event that can be triggered manually to verify webhook configuration.
-
-## Webhook Request Format
-
-### Headers
-
-All webhook requests include the following headers:
-
-| Header | Description | Example |
-|--------|-------------|---------|
-| `Content-Type` | Always `application/json` | `application/json` |
-| `User-Agent` | Identifies Reflector as the source | `Reflector-Webhook/1.0` |
-| `X-Webhook-Event` | The event type | `transcript.completed` or `test` |
-| `X-Webhook-Retry` | Current retry attempt number | `0`, `1`, `2`... |
-| `X-Webhook-Signature` | HMAC signature (if secret configured) | `t=1735306800,v1=abc123...` |
-
-### Signature Verification
-
-If a webhook secret is configured, Reflector includes an HMAC-SHA256 signature in the `X-Webhook-Signature` header to verify the webhook authenticity.
-
-The signature format is: `t={timestamp},v1={signature}`
-
-To verify the signature:
-1. Extract the timestamp and signature from the header
-2. Create the signed payload: `{timestamp}.{request_body}`
-3. Compute HMAC-SHA256 of the signed payload using your webhook secret
-4. Compare the computed signature with the received signature
-
-Example verification (Python):
-```python
-import hmac
-import hashlib
-
-def verify_webhook_signature(payload: bytes, signature_header: str, secret: str) -> bool:
-    # Parse header: "t=1735306800,v1=abc123..."
-    parts = dict(part.split("=") for part in signature_header.split(","))
-    timestamp = parts["t"]
-    received_signature = parts["v1"]
-
-    # Create signed payload
-    signed_payload = f"{timestamp}.{payload.decode('utf-8')}"
-
-    # Compute expected signature
-    expected_signature = hmac.new(
-        secret.encode("utf-8"),
-        signed_payload.encode("utf-8"),
-        hashlib.sha256
-    ).hexdigest()
-
-    # Compare signatures
-    return hmac.compare_digest(expected_signature, received_signature)
-```
-
-## Event Payloads
-
-### `transcript.completed` Event
-
-This event includes a convenient URL for accessing the transcript:
- `frontend_url`: Direct link to view the transcript in the web interface
-
-```json
-{
-  "event": "transcript.completed",
-  "event_id": "transcript.completed-abc-123-def-456",
-  "timestamp": "2025-08-27T12:34:56.789012Z",
-  "transcript": {
-    "id": "abc-123-def-456",
-    "room_id": "room-789",
-    "created_at": "2025-08-27T12:00:00Z",
-    "duration": 1800.5,
-    "title": "Q3 Product Planning Meeting",
-    "short_summary": "Team discussed Q3 product roadmap, prioritizing mobile app features and API improvements.",
-    "long_summary": "The product team met to finalize the Q3 roadmap. Key decisions included...",
-    "webvtt": "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\n<v Speaker 1>Welcome everyone to today's meeting...",
-    "topics": [
-      {
-        "title": "Introduction and Agenda",
-        "summary": "Meeting kickoff with agenda review",
-        "timestamp": 0.0,
-        "duration": 120.0,
-        "webvtt": "WEBVTT\n\n00:00:00.000 --> 00:00:05.000\n<v Speaker 1>Welcome everyone..."
-      },
-      {
-        "title": "Mobile App Features Discussion",
-        "summary": "Team reviewed proposed mobile app features for Q3",
-        "timestamp": 120.0,
-        "duration": 600.0,
-        "webvtt": "WEBVTT\n\n00:02:00.000 --> 00:02:10.000\n<v Speaker 2>Let's talk about the mobile app..."
-      }
-    ],
-    "participants": [
-      {
-        "id": "participant-1",
-        "name": "John Doe",
-        "speaker": "Speaker 1"
-      },
-      {
-        "id": "participant-2",
-        "name": "Jane Smith",
-        "speaker": "Speaker 2"
-      }
-    ],
-    "source_language": "en",
-    "target_language": "en",
-    "status": "completed",
-    "frontend_url": "https://app.reflector.com/transcripts/abc-123-def-456"
-  },
-  "room": {
-    "id": "room-789",
-    "name": "Product Team Room"
-  }
-}
-```
-
-### `test` Event
-
-```json
-{
-  "event": "test",
-  "event_id": "test.2025-08-27T12:34:56.789012Z",
-  "timestamp": "2025-08-27T12:34:56.789012Z",
-  "message": "This is a test webhook from Reflector",
-  "room": {
-    "id": "room-789",
-    "name": "Product Team Room"
-  }
-}
-```
-
-## Retry Policy
-
-Webhooks are delivered with automatic retry logic to handle transient failures. When a webhook delivery fails due to server errors or network issues, Reflector will automatically retry the delivery multiple times over an extended period.
-
-### Retry Mechanism
-
-Reflector implements an exponential backoff strategy for webhook retries:
-
- **Initial retry delay**: 60 seconds after the first failure
- **Exponential backoff**: Each subsequent retry waits approximately twice as long as the previous one
- **Maximum retry interval**: 1 hour (backoff is capped at this duration)
- **Maximum retry attempts**: 30 attempts total
- **Total retry duration**: Retries continue for approximately 24 hours
-
-### How Retries Work
-
-When a webhook fails, Reflector will:
-1. Wait 60 seconds, then retry (attempt #1)
-2. If it fails again, wait ~2 minutes, then retry (attempt #2)
-3. Continue doubling the wait time up to a maximum of 1 hour between attempts
-4. Keep retrying at 1-hour intervals until successful or 30 attempts are exhausted
-
-The `X-Webhook-Retry` header indicates the current retry attempt number (0 for the initial attempt, 1 for first retry, etc.), allowing your endpoint to track retry attempts.
-
-### Retry Behavior by HTTP Status Code
-
-| Status Code | Behavior |
-|-------------|----------|
-| 2xx (Success) | No retry, webhook marked as delivered |
-| 4xx (Client Error) | No retry, request is considered permanently failed |
-| 5xx (Server Error) | Automatic retry with exponential backoff |
-| Network/Timeout Error | Automatic retry with exponential backoff |
-
-**Important Notes:**
- Webhooks timeout after 30 seconds. If your endpoint takes longer to respond, it will be considered a timeout error and retried.
- During the retry period (~24 hours), you may receive the same webhook multiple times if your endpoint experiences intermittent failures.
- There is no mechanism to manually retry failed webhooks after the retry period expires.
-
-## Testing Webhooks
-
-You can test your webhook configuration before processing transcripts:
-
-```http
-POST /v1/rooms/{room_id}/webhook/test
-```
-
-Response:
-```json
-{
-  "success": true,
-  "status_code": 200,
-  "message": "Webhook test successful",
-  "response_preview": "OK"
-}
-```
-
-Or in case of failure:
-```json
-{
-  "success": false,
-  "error": "Webhook request timed out (10 seconds)"
-}
-```
--- a/server/env.example
+++ b/server/env.example
@@ -20,24 +20,24 @@ AUTH_JWT_AUDIENCE=

 ## Using local whisper
 #TRANSCRIPT_BACKEND=whisper
+#WHISPER_MODEL_SIZE=tiny

 ## Using serverless modal.com (require reflector-gpu-modal deployed)
 #TRANSCRIPT_BACKEND=modal
 #TRANSCRIPT_URL=https://xxxxx--reflector-transcriber-web.modal.run
+#TRANSLATE_URL=https://xxxxx--reflector-translator-web.modal.run
 #TRANSCRIPT_MODAL_API_KEY=xxxxx

 TRANSCRIPT_BACKEND=modal
 TRANSCRIPT_URL=https://monadical-sas--reflector-transcriber-web.modal.run
-TRANSCRIPT_MODAL_API_KEY=
+TRANSCRIPT_MODAL_API_KEY=***REMOVED***

 ## =======================================================
-## Translation backend
+## Transcription backend
 ##
 ## Only available in modal atm
 ## =======================================================
-TRANSLATION_BACKEND=modal
 TRANSLATE_URL=https://monadical-sas--reflector-translator-web.modal.run
-#TRANSLATION_MODAL_API_KEY=xxxxx

 ## =======================================================
 ## LLM backend
@@ -47,11 +47,28 @@ TRANSLATE_URL=https://monadical-sas--reflector-translator-web.modal.run
 ## llm backend implementation
 ## =======================================================

-## Context size for summary generation (tokens)
-# LLM_MODEL=microsoft/phi-4
-LLM_CONTEXT_WINDOW=16000
-LLM_URL=
-LLM_API_KEY=sk-
+## Using serverless modal.com (require reflector-gpu-modal deployed)
+LLM_BACKEND=modal
+LLM_URL=https://monadical-sas--reflector-llm-web.modal.run
+LLM_MODAL_API_KEY=***REMOVED***
+ZEPHYR_LLM_URL=https://monadical-sas--reflector-llm-zephyr-web.modal.run
+
+
+## Using OpenAI
+#LLM_BACKEND=openai
+#LLM_OPENAI_KEY=xxx
+#LLM_OPENAI_MODEL=gpt-3.5-turbo
+
+## Using GPT4ALL
+#LLM_BACKEND=openai
+#LLM_URL=http://localhost:4891/v1/completions
+#LLM_OPENAI_MODEL="GPT4All Falcon"
+
+## Default LLM MODEL NAME
+#DEFAULT_LLM=lmsys/vicuna-13b-v1.5
+
+## Cache directory to store models
+CACHE_DIR=data

 ## =======================================================
 ## Diarization
@@ -60,9 +77,7 @@ LLM_API_KEY=sk-
 ## To allow diarization, you need to expose expose the files to be dowloded by the pipeline
 ## =======================================================
 DIARIZATION_ENABLED=false
-DIARIZATION_BACKEND=modal
 DIARIZATION_URL=https://monadical-sas--reflector-diarizer-web.modal.run
-#DIARIZATION_MODAL_API_KEY=xxxxx


 ## =======================================================
--- a/server/gpu/modal_deployments/README.md
+++ b/server/gpu/modal_deployments/README.md
@@ -3,10 +3,8 @@
 This repository hold an API for the GPU implementation of the Reflector API service,
 and use [Modal.com](https://modal.com)

- `reflector_diarizer.py` - Diarization API
- `reflector_transcriber.py` - Transcription API (Whisper)
- `reflector_transcriber_parakeet.py` - Transcription API (NVIDIA Parakeet)
- `reflector_translator.py` - Translation API
+- `reflector_llm.py` - LLM API
+- `reflector_transcriber.py` - Transcription API

 ## Modal.com deployment

@@ -20,29 +18,21 @@ $ modal deploy reflector_transcriber.py
 ...
 └── 🔨 Created web => https://xxxx--reflector-transcriber-web.modal.run

-$ modal deploy reflector_transcriber_parakeet.py
-...
-└── 🔨 Created web => https://xxxx--reflector-transcriber-parakeet-web.modal.run
-
 $ modal deploy reflector_llm.py
 ...
 └── 🔨 Created web => https://xxxx--reflector-llm-web.modal.run
 ```

-Then in your reflector api configuration `.env`, you can set these keys:
+Then in your reflector api configuration `.env`, you can set theses keys:

 ```
 TRANSCRIPT_BACKEND=modal
 TRANSCRIPT_URL=https://xxxx--reflector-transcriber-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=REFLECTOR_APIKEY

-DIARIZATION_BACKEND=modal
-DIARIZATION_URL=https://xxxx--reflector-diarizer-web.modal.run
-DIARIZATION_MODAL_API_KEY=REFLECTOR_APIKEY
-
-TRANSLATION_BACKEND=modal
-TRANSLATION_URL=https://xxxx--reflector-translator-web.modal.run
-TRANSLATION_MODAL_API_KEY=REFLECTOR_APIKEY
+LLM_BACKEND=modal
+LLM_URL=https://xxxx--reflector-llm-web.modal.run
+LLM_MODAL_API_KEY=REFLECTOR_APIKEY
 ```

 ## API
@@ -73,86 +63,6 @@ Authorization: bearer <REFLECTOR_APIKEY>

 ### Transcription

-#### Parakeet Transcriber (`reflector_transcriber_parakeet.py`)
-
-NVIDIA Parakeet is a state-of-the-art ASR model optimized for real-time transcription with superior word-level timestamps.
-
-**GPU Configuration:**
- **A10G GPU** - Used for `/v1/audio/transcriptions` endpoint (small files, live transcription)
-  - Higher concurrency (max_inputs=10)
-  - Optimized for multiple small audio files
-  - Supports batch processing for efficiency
-
- **L40S GPU** - Used for `/v1/audio/transcriptions-from-url` endpoint (large files)
-  - Lower concurrency but more powerful processing
-  - Optimized for single large audio files
-  - VAD-based chunking for long-form audio
-
-##### `/v1/audio/transcriptions` - Small file transcription
-
-**request** (multipart/form-data)
- `file` or `files[]` - audio file(s) to transcribe
- `model` - model name (default: `nvidia/parakeet-tdt-0.6b-v2`)
- `language` - language code (default: `en`)
- `batch` - whether to use batch processing for multiple files (default: `true`)
-
-**response**
-```json
-{
-    "text": "transcribed text",
-    "words": [
-        {"word": "hello", "start": 0.0, "end": 0.5},
-        {"word": "world", "start": 0.5, "end": 1.0}
-    ],
-    "filename": "audio.mp3"
-}
-```
-
-For multiple files with batch=true:
-```json
-{
-    "results": [
-        {
-            "filename": "audio1.mp3",
-            "text": "transcribed text",
-            "words": [...]
-        },
-        {
-            "filename": "audio2.mp3",
-            "text": "transcribed text",
-            "words": [...]
-        }
-    ]
-}
-```
-
-##### `/v1/audio/transcriptions-from-url` - Large file transcription
-
-**request** (application/json)
-```json
-{
-    "audio_file_url": "https://example.com/audio.mp3",
-    "model": "nvidia/parakeet-tdt-0.6b-v2",
-    "language": "en",
-    "timestamp_offset": 0.0
-}
-```
-
-**response**
-```json
-{
-    "text": "transcribed text from large file",
-    "words": [
-        {"word": "hello", "start": 0.0, "end": 0.5},
-        {"word": "world", "start": 0.5, "end": 1.0}
-    ]
-}
-```
-
-**Supported file types:** mp3, mp4, mpeg, mpga, m4a, wav, webm
-
-#### Whisper Transcriber (`reflector_transcriber.py`)
-
 `POST /transcribe`

 **request** (multipart/form-data)
--- a/server/gpu/modal_deployments/reflector_diarizer.py
+++ b/server/gpu/modal_deployments/reflector_diarizer.py
@@ -4,80 +4,14 @@ Reflector GPU backend - diarizer
 """

 import os
-import uuid
-from typing import Mapping, NewType
-from urllib.parse import urlparse

-import modal
+import modal.gpu
+from modal import App, Image, Secret, asgi_app, enter, method
+from pydantic import BaseModel

 PYANNOTE_MODEL_NAME: str = "pyannote/speaker-diarization-3.1"
 MODEL_DIR = "/root/diarization_models"
-UPLOADS_PATH = "/uploads"
-SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
-
-DiarizerUniqFilename = NewType("DiarizerUniqFilename", str)
-AudioFileExtension = NewType("AudioFileExtension", str)
-
-app = modal.App(name="reflector-diarizer")
-
-# Volume for temporary file uploads
-upload_volume = modal.Volume.from_name("diarizer-uploads", create_if_missing=True)
-
-
-def detect_audio_format(url: str, headers: Mapping[str, str]) -> AudioFileExtension:
-    parsed_url = urlparse(url)
-    url_path = parsed_url.path
-
-    for ext in SUPPORTED_FILE_EXTENSIONS:
-        if url_path.lower().endswith(f".{ext}"):
-            return AudioFileExtension(ext)
-
-    content_type = headers.get("content-type", "").lower()
-    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
-        return AudioFileExtension("mp3")
-    if "audio/wav" in content_type:
-        return AudioFileExtension("wav")
-    if "audio/mp4" in content_type:
-        return AudioFileExtension("mp4")
-
-    raise ValueError(
-        f"Unsupported audio format for URL: {url}. "
-        f"Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
-    )
-
-
-def download_audio_to_volume(
-    audio_file_url: str,
-) -> tuple[DiarizerUniqFilename, AudioFileExtension]:
-    import requests
-    from fastapi import HTTPException
-
-    print(f"Checking audio file at: {audio_file_url}")
-    response = requests.head(audio_file_url, allow_redirects=True)
-    if response.status_code == 404:
-        raise HTTPException(status_code=404, detail="Audio file not found")
-
-    print(f"Downloading audio file from: {audio_file_url}")
-    response = requests.get(audio_file_url, allow_redirects=True)
-
-    if response.status_code != 200:
-        print(f"Download failed with status {response.status_code}: {response.text}")
-        raise HTTPException(
-            status_code=response.status_code,
-            detail=f"Failed to download audio file: {response.status_code}",
-        )
-
-    audio_suffix = detect_audio_format(audio_file_url, response.headers)
-    unique_filename = DiarizerUniqFilename(f"{uuid.uuid4()}.{audio_suffix}")
-    file_path = f"{UPLOADS_PATH}/{unique_filename}"
-
-    print(f"Writing file to: {file_path} (size: {len(response.content)} bytes)")
-    with open(file_path, "wb") as f:
-        f.write(response.content)
-
-    upload_volume.commit()
-    print(f"File saved as: {unique_filename}")
-    return unique_filename, audio_suffix
+app = App(name="reflector-diarizer")


 def migrate_cache_llm():
@@ -105,7 +39,7 @@ def download_pyannote_audio():


 diarizer_image = (
-    modal.Image.debian_slim(python_version="3.10.8")
+    Image.debian_slim(python_version="3.10.8")
    .pip_install(
        "pyannote.audio==3.1.0",
        "requests",
@@ -121,8 +55,7 @@ diarizer_image = (
        "hf-transfer",
    )
    .run_function(
-        download_pyannote_audio,
-        secrets=[modal.Secret.from_name("hf_token")],
+        download_pyannote_audio, secrets=[Secret.from_name("my-huggingface-secret")]
    )
    .run_function(migrate_cache_llm)
    .env(
@@ -137,60 +70,53 @@ diarizer_image = (


@app.cls(
-    gpu="A100",
+    gpu=modal.gpu.A100(size="40GB"),
    timeout=60 * 30,
+    scaledown_window=60,
+    allow_concurrent_inputs=1,
    image=diarizer_image,
-    volumes={UPLOADS_PATH: upload_volume},
-    enable_memory_snapshot=True,
-    experimental_options={"enable_gpu_snapshot": True},
-    secrets=[
-        modal.Secret.from_name("hf_token"),
-    ],
 )
-@modal.concurrent(max_inputs=1)
 class Diarizer:
-    @modal.enter(snap=True)
+    @enter()
    def enter(self):
        import torch
        from pyannote.audio import Pipeline

        self.use_gpu = torch.cuda.is_available()
        self.device = "cuda" if self.use_gpu else "cpu"
-        print(f"Using device: {self.device}")
        self.diarization_pipeline = Pipeline.from_pretrained(
-            PYANNOTE_MODEL_NAME,
-            cache_dir=MODEL_DIR,
-            use_auth_token=os.environ["HF_TOKEN"],
+            PYANNOTE_MODEL_NAME, cache_dir=MODEL_DIR
        )
        self.diarization_pipeline.to(torch.device(self.device))

-    @modal.method()
-    def diarize(self, filename: str, timestamp: float = 0.0):
+    @method()
+    def diarize(self, audio_data: str, audio_suffix: str, timestamp: float):
+        import tempfile
+
        import torchaudio

-        upload_volume.reload()
+        with tempfile.NamedTemporaryFile("wb+", suffix=f".{audio_suffix}") as fp:
+            fp.write(audio_data)

-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        print(f"Diarizing audio from: {file_path}")
-        waveform, sample_rate = torchaudio.load(file_path)
-        diarization = self.diarization_pipeline(
-            {"waveform": waveform, "sample_rate": sample_rate}
-        )
-
-        words = []
-        for diarization_segment, _, speaker in diarization.itertracks(yield_label=True):
-            words.append(
-                {
-                    "start": round(timestamp + diarization_segment.start, 3),
-                    "end": round(timestamp + diarization_segment.end, 3),
-                    "speaker": int(speaker[-2:]),
-                }
+            print("Diarizing audio")
+            waveform, sample_rate = torchaudio.load(fp.name)
+            diarization = self.diarization_pipeline(
+                {"waveform": waveform, "sample_rate": sample_rate}
            )
-        print("Diarization complete")
-        return {"diarization": words}
+
+            words = []
+            for diarization_segment, _, speaker in diarization.itertracks(
+                yield_label=True
+            ):
+                words.append(
+                    {
+                        "start": round(timestamp + diarization_segment.start, 3),
+                        "end": round(timestamp + diarization_segment.end, 3),
+                        "speaker": int(speaker[-2:]),
+                    }
+                )
+            print("Diarization complete")
+            return {"diarization": words}


 # -------------------------------------------------------------------
@@ -201,18 +127,17 @@ class Diarizer:
@app.function(
    timeout=60 * 10,
    scaledown_window=60 * 3,
+    allow_concurrent_inputs=40,
    secrets=[
-        modal.Secret.from_name("reflector-gpu"),
+        Secret.from_name("reflector-gpu"),
    ],
-    volumes={UPLOADS_PATH: upload_volume},
    image=diarizer_image,
 )
-@modal.concurrent(max_inputs=40)
-@modal.asgi_app()
+@asgi_app()
 def web():
+    import requests
    from fastapi import Depends, FastAPI, HTTPException, status
    from fastapi.security import OAuth2PasswordBearer
-    from pydantic import BaseModel

    diarizerstub = Diarizer()

@@ -228,26 +153,35 @@ def web():
                headers={"WWW-Authenticate": "Bearer"},
            )

+    def validate_audio_file(audio_file_url: str):
+        # Check if the audio file exists
+        response = requests.head(audio_file_url, allow_redirects=True)
+        if response.status_code == 404:
+            raise HTTPException(
+                status_code=response.status_code,
+                detail="The audio file does not exist.",
+            )
+
    class DiarizationResponse(BaseModel):
        result: dict

-    @app.post("/diarize", dependencies=[Depends(apikey_auth)])
-    def diarize(audio_file_url: str, timestamp: float = 0.0) -> DiarizationResponse:
-        unique_filename, audio_suffix = download_audio_to_volume(audio_file_url)
+    @app.post(
+        "/diarize", dependencies=[Depends(apikey_auth), Depends(validate_audio_file)]
+    )
+    def diarize(
+        audio_file_url: str, timestamp: float = 0.0
+    ) -> HTTPException | DiarizationResponse:
+        # Currently the uploaded files are in mp3 format
+        audio_suffix = "mp3"

-        try:
-            func = diarizerstub.diarize.spawn(
-                filename=unique_filename, timestamp=timestamp
-            )
-            result = func.get()
-            return result
-        finally:
-            try:
-                file_path = f"{UPLOADS_PATH}/{unique_filename}"
-                print(f"Deleting file: {file_path}")
-                os.remove(file_path)
-                upload_volume.commit()
-            except Exception as e:
-                print(f"Error cleaning up {unique_filename}: {e}")
+        print("Downloading audio file")
+        response = requests.get(audio_file_url, allow_redirects=True)
+        print("Audio file downloaded successfully")
+
+        func = diarizerstub.diarize.spawn(
+            audio_data=response.content, audio_suffix=audio_suffix, timestamp=timestamp
+        )
+        result = func.get()
+        return result

    return app
--- a/server/gpu/modal_deployments/reflector_llm.py
+++ b/server/gpu/modal_deployments/reflector_llm.py
@@ -0,0 +1,214 @@
+"""
+Reflector GPU backend - LLM
+===========================
+
+"""
+
+import json
+import os
+import threading
+from typing import Optional
+
+import modal
+from modal import App, Image, Secret, asgi_app, enter, exit, method
+
+# LLM
+LLM_MODEL: str = "lmsys/vicuna-13b-v1.5"
+LLM_LOW_CPU_MEM_USAGE: bool = True
+LLM_TORCH_DTYPE: str = "bfloat16"
+LLM_MAX_NEW_TOKENS: int = 300
+
+IMAGE_MODEL_DIR = "/root/llm_models"
+
+app = App(name="reflector-llm")
+
+
+def download_llm():
+    from huggingface_hub import snapshot_download
+
+    print("Downloading LLM model")
+    snapshot_download(LLM_MODEL, cache_dir=IMAGE_MODEL_DIR)
+    print("LLM model downloaded")
+
+
+def migrate_cache_llm():
+    """
+    XXX The cache for model files in Transformers v4.22.0 has been updated.
+    Migrating your old cache. This is a one-time only operation. You can
+    interrupt this and resume the migration later on by calling
+    `transformers.utils.move_cache()`.
+    """
+    from transformers.utils.hub import move_cache
+
+    print("Moving LLM cache")
+    move_cache(cache_dir=IMAGE_MODEL_DIR, new_cache_dir=IMAGE_MODEL_DIR)
+    print("LLM cache moved")
+
+
+llm_image = (
+    Image.debian_slim(python_version="3.10.8")
+    .apt_install("git")
+    .pip_install(
+        "transformers",
+        "torch",
+        "sentencepiece",
+        "protobuf",
+        "jsonformer==0.12.0",
+        "accelerate==0.21.0",
+        "einops==0.6.1",
+        "hf-transfer~=0.1",
+        "huggingface_hub==0.16.4",
+    )
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
+    .run_function(download_llm)
+    .run_function(migrate_cache_llm)
+)
+
+
+@app.cls(
+    gpu="A100",
+    timeout=60 * 5,
+    scaledown_window=60 * 5,
+    allow_concurrent_inputs=15,
+    image=llm_image,
+)
+class LLM:
+    @enter()
+    def enter(self):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+        print("Instance llm model")
+        model = AutoModelForCausalLM.from_pretrained(
+            LLM_MODEL,
+            torch_dtype=getattr(torch, LLM_TORCH_DTYPE),
+            low_cpu_mem_usage=LLM_LOW_CPU_MEM_USAGE,
+            cache_dir=IMAGE_MODEL_DIR,
+            local_files_only=True,
+        )
+
+        # JSONFormer doesn't yet support generation configs
+        print("Instance llm generation config")
+        model.config.max_new_tokens = LLM_MAX_NEW_TOKENS
+
+        # generation configuration
+        gen_cfg = GenerationConfig.from_model_config(model.config)
+        gen_cfg.max_new_tokens = LLM_MAX_NEW_TOKENS
+
+        # load tokenizer
+        print("Instance llm tokenizer")
+        tokenizer = AutoTokenizer.from_pretrained(
+            LLM_MODEL, cache_dir=IMAGE_MODEL_DIR, local_files_only=True
+        )
+
+        # move model to gpu
+        print("Move llm model to GPU")
+        model = model.cuda()
+
+        print("Warmup llm done")
+        self.model = model
+        self.tokenizer = tokenizer
+        self.gen_cfg = gen_cfg
+        self.GenerationConfig = GenerationConfig
+
+        self.lock = threading.Lock()
+
+    @exit()
+    def exit():
+        print("Exit llm")
+
+    @method()
+    def generate(
+        self, prompt: str, gen_schema: str | None, gen_cfg: str | None
+    ) -> dict:
+        """
+        Perform a generation action using the LLM
+        """
+        print(f"Generate {prompt=}")
+        if gen_cfg:
+            gen_cfg = self.GenerationConfig.from_dict(json.loads(gen_cfg))
+        else:
+            gen_cfg = self.gen_cfg
+
+        # If a gen_schema is given, conform to gen_schema
+        with self.lock:
+            if gen_schema:
+                import jsonformer
+
+                print(f"Schema {gen_schema=}")
+                jsonformer_llm = jsonformer.Jsonformer(
+                    model=self.model,
+                    tokenizer=self.tokenizer,
+                    json_schema=json.loads(gen_schema),
+                    prompt=prompt,
+                    max_string_token_length=gen_cfg.max_new_tokens,
+                )
+                response = jsonformer_llm()
+            else:
+                # If no gen_schema, perform prompt only generation
+
+                # tokenize prompt
+                input_ids = self.tokenizer.encode(prompt, return_tensors="pt").to(
+                    self.model.device
+                )
+                output = self.model.generate(input_ids, generation_config=gen_cfg)
+
+                # decode output
+                response = self.tokenizer.decode(
+                    output[0].cpu(), skip_special_tokens=True
+                )
+                response = response[len(prompt) :]
+        print(f"Generated {response=}")
+        return {"text": response}
+
+
+# -------------------------------------------------------------------
+# Web API
+# -------------------------------------------------------------------
+
+
+@app.function(
+    scaledown_window=60 * 10,
+    timeout=60 * 5,
+    allow_concurrent_inputs=45,
+    secrets=[
+        Secret.from_name("reflector-gpu"),
+    ],
+)
+@asgi_app()
+def web():
+    from fastapi import Depends, FastAPI, HTTPException, status
+    from fastapi.security import OAuth2PasswordBearer
+    from pydantic import BaseModel
+
+    llmstub = LLM()
+
+    app = FastAPI()
+    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
+        if apikey != os.environ["REFLECTOR_GPU_APIKEY"]:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid API key",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+    class LLMRequest(BaseModel):
+        prompt: str
+        gen_schema: Optional[dict] = None
+        gen_cfg: Optional[dict] = None
+
+    @app.post("/llm", dependencies=[Depends(apikey_auth)])
+    def llm(
+        req: LLMRequest,
+    ):
+        gen_schema = json.dumps(req.gen_schema) if req.gen_schema else None
+        gen_cfg = json.dumps(req.gen_cfg) if req.gen_cfg else None
+        func = llmstub.generate.spawn(
+            prompt=req.prompt, gen_schema=gen_schema, gen_cfg=gen_cfg
+        )
+        result = func.get()
+        return result
+
+    return app
--- a/server/gpu/modal_deployments/reflector_llm_zephyr.py
+++ b/server/gpu/modal_deployments/reflector_llm_zephyr.py
@@ -0,0 +1,220 @@
+"""
+Reflector GPU backend - LLM
+===========================
+
+"""
+
+import json
+import os
+import threading
+from typing import Optional
+
+import modal
+from modal import App, Image, Secret, asgi_app, enter, exit, method
+
+# LLM
+LLM_MODEL: str = "HuggingFaceH4/zephyr-7b-alpha"
+LLM_LOW_CPU_MEM_USAGE: bool = True
+LLM_TORCH_DTYPE: str = "bfloat16"
+LLM_MAX_NEW_TOKENS: int = 300
+
+IMAGE_MODEL_DIR = "/root/llm_models/zephyr"
+
+app = App(name="reflector-llm-zephyr")
+
+
+def download_llm():
+    from huggingface_hub import snapshot_download
+
+    print("Downloading LLM model")
+    snapshot_download(LLM_MODEL, cache_dir=IMAGE_MODEL_DIR)
+    print("LLM model downloaded")
+
+
+def migrate_cache_llm():
+    """
+    XXX The cache for model files in Transformers v4.22.0 has been updated.
+    Migrating your old cache. This is a one-time only operation. You can
+    interrupt this and resume the migration later on by calling
+    `transformers.utils.move_cache()`.
+    """
+    from transformers.utils.hub import move_cache
+
+    print("Moving LLM cache")
+    move_cache(cache_dir=IMAGE_MODEL_DIR, new_cache_dir=IMAGE_MODEL_DIR)
+    print("LLM cache moved")
+
+
+llm_image = (
+    Image.debian_slim(python_version="3.10.8")
+    .apt_install("git")
+    .pip_install(
+        "transformers==4.34.0",
+        "torch",
+        "sentencepiece",
+        "protobuf",
+        "jsonformer==0.12.0",
+        "accelerate==0.21.0",
+        "einops==0.6.1",
+        "hf-transfer~=0.1",
+        "huggingface_hub==0.16.4",
+    )
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
+    .run_function(download_llm)
+    .run_function(migrate_cache_llm)
+)
+
+
+@app.cls(
+    gpu="A10G",
+    timeout=60 * 5,
+    scaledown_window=60 * 5,
+    allow_concurrent_inputs=10,
+    image=llm_image,
+)
+class LLM:
+    @enter()
+    def enter(self):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+        print("Instance llm model")
+        model = AutoModelForCausalLM.from_pretrained(
+            LLM_MODEL,
+            torch_dtype=getattr(torch, LLM_TORCH_DTYPE),
+            low_cpu_mem_usage=LLM_LOW_CPU_MEM_USAGE,
+            cache_dir=IMAGE_MODEL_DIR,
+            local_files_only=True,
+        )
+
+        # JSONFormer doesn't yet support generation configs
+        print("Instance llm generation config")
+        model.config.max_new_tokens = LLM_MAX_NEW_TOKENS
+
+        # generation configuration
+        gen_cfg = GenerationConfig.from_model_config(model.config)
+        gen_cfg.max_new_tokens = LLM_MAX_NEW_TOKENS
+
+        # load tokenizer
+        print("Instance llm tokenizer")
+        tokenizer = AutoTokenizer.from_pretrained(
+            LLM_MODEL, cache_dir=IMAGE_MODEL_DIR, local_files_only=True
+        )
+        gen_cfg.pad_token_id = tokenizer.eos_token_id
+        gen_cfg.eos_token_id = tokenizer.eos_token_id
+        tokenizer.pad_token = tokenizer.eos_token
+        model.config.pad_token_id = tokenizer.eos_token_id
+
+        # move model to gpu
+        print("Move llm model to GPU")
+        model = model.cuda()
+
+        print("Warmup llm done")
+        self.model = model
+        self.tokenizer = tokenizer
+        self.gen_cfg = gen_cfg
+        self.GenerationConfig = GenerationConfig
+        self.lock = threading.Lock()
+
+    @exit()
+    def exit():
+        print("Exit llm")
+
+    @method()
+    def generate(
+        self, prompt: str, gen_schema: str | None, gen_cfg: str | None
+    ) -> dict:
+        """
+        Perform a generation action using the LLM
+        """
+        print(f"Generate {prompt=}")
+        if gen_cfg:
+            gen_cfg = self.GenerationConfig.from_dict(json.loads(gen_cfg))
+            gen_cfg.pad_token_id = self.tokenizer.eos_token_id
+            gen_cfg.eos_token_id = self.tokenizer.eos_token_id
+        else:
+            gen_cfg = self.gen_cfg
+
+        # If a gen_schema is given, conform to gen_schema
+        with self.lock:
+            if gen_schema:
+                import jsonformer
+
+                print(f"Schema {gen_schema=}")
+                jsonformer_llm = jsonformer.Jsonformer(
+                    model=self.model,
+                    tokenizer=self.tokenizer,
+                    json_schema=json.loads(gen_schema),
+                    prompt=prompt,
+                    max_string_token_length=gen_cfg.max_new_tokens,
+                )
+                response = jsonformer_llm()
+            else:
+                # If no gen_schema, perform prompt only generation
+
+                # tokenize prompt
+                input_ids = self.tokenizer.encode(prompt, return_tensors="pt").to(
+                    self.model.device
+                )
+                output = self.model.generate(input_ids, generation_config=gen_cfg)
+
+                # decode output
+                response = self.tokenizer.decode(
+                    output[0].cpu(), skip_special_tokens=True
+                )
+                response = response[len(prompt) :]
+                response = {"long_summary": response}
+        print(f"Generated {response=}")
+        return {"text": response}
+
+
+# -------------------------------------------------------------------
+# Web API
+# -------------------------------------------------------------------
+
+
+@app.function(
+    scaledown_window=60 * 10,
+    timeout=60 * 5,
+    allow_concurrent_inputs=30,
+    secrets=[
+        Secret.from_name("reflector-gpu"),
+    ],
+)
+@asgi_app()
+def web():
+    from fastapi import Depends, FastAPI, HTTPException, status
+    from fastapi.security import OAuth2PasswordBearer
+    from pydantic import BaseModel
+
+    llmstub = LLM()
+
+    app = FastAPI()
+    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
+        if apikey != os.environ["REFLECTOR_GPU_APIKEY"]:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid API key",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+    class LLMRequest(BaseModel):
+        prompt: str
+        gen_schema: Optional[dict] = None
+        gen_cfg: Optional[dict] = None
+
+    @app.post("/llm", dependencies=[Depends(apikey_auth)])
+    def llm(
+        req: LLMRequest,
+    ):
+        gen_schema = json.dumps(req.gen_schema) if req.gen_schema else None
+        gen_cfg = json.dumps(req.gen_cfg) if req.gen_cfg else None
+        func = llmstub.generate.spawn(
+            prompt=req.prompt, gen_schema=gen_schema, gen_cfg=gen_cfg
+        )
+        result = func.get()
+        return result
+
+    return app
--- a/server/gpu/modal_deployments/reflector_transcriber.py
+++ b/server/gpu/modal_deployments/reflector_transcriber.py
@@ -1,78 +1,41 @@
 import os
-import sys
+import tempfile
 import threading
-import uuid
-from typing import Generator, Mapping, NamedTuple, NewType, TypedDict
-from urllib.parse import urlparse

 import modal
+from pydantic import BaseModel
+
+MODELS_DIR = "/models"

 MODEL_NAME = "large-v2"
 MODEL_COMPUTE_TYPE: str = "float16"
 MODEL_NUM_WORKERS: int = 1
+
 MINUTES = 60  # seconds
-SAMPLERATE = 16000
-UPLOADS_PATH = "/uploads"
-CACHE_PATH = "/models"
-SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
-VAD_CONFIG = {
-    "batch_max_duration": 30.0,
-    "silence_padding": 0.5,
-    "window_size": 512,
-}

-
-WhisperUniqFilename = NewType("WhisperUniqFilename", str)
-AudioFileExtension = NewType("AudioFileExtension", str)
+volume = modal.Volume.from_name("models", create_if_missing=True)

 app = modal.App("reflector-transcriber")

-model_cache = modal.Volume.from_name("models", create_if_missing=True)
-upload_volume = modal.Volume.from_name("whisper-uploads", create_if_missing=True)
-
-
-class TimeSegment(NamedTuple):
-    """Represents a time segment with start and end times."""
-
-    start: float
-    end: float
-
-
-class AudioSegment(NamedTuple):
-    """Represents an audio segment with timing and audio data."""
-
-    start: float
-    end: float
-    audio: any
-
-
-class TranscriptResult(NamedTuple):
-    """Represents a transcription result with text and word timings."""
-
-    text: str
-    words: list["WordTiming"]
-
-
-class WordTiming(TypedDict):
-    """Represents a word with its timing information."""
-
-    word: str
-    start: float
-    end: float
-

 def download_model():
    from faster_whisper import download_model

-    model_cache.reload()
+    volume.reload()

-    download_model(MODEL_NAME, cache_dir=CACHE_PATH)
+    download_model(MODEL_NAME, cache_dir=MODELS_DIR)

-    model_cache.commit()
+    volume.commit()


 image = (
    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "huggingface_hub==0.27.1",
+        "hf-transfer==0.1.9",
+        "torch==2.5.1",
+        "faster-whisper==1.1.1",
+    )
    .env(
        {
            "HF_HUB_ENABLE_HF_TRANSFER": "1",
@@ -82,98 +45,19 @@ image = (
            ),
        }
    )
-    .apt_install("ffmpeg")
-    .pip_install(
-        "huggingface_hub==0.27.1",
-        "hf-transfer==0.1.9",
-        "torch==2.5.1",
-        "faster-whisper==1.1.1",
-        "fastapi==0.115.12",
-        "requests",
-        "librosa==0.10.1",
-        "numpy<2",
-        "silero-vad==5.1.0",
-    )
-    .run_function(download_model, volumes={CACHE_PATH: model_cache})
+    .run_function(download_model, volumes={MODELS_DIR: volume})
 )


-def detect_audio_format(url: str, headers: Mapping[str, str]) -> AudioFileExtension:
-    parsed_url = urlparse(url)
-    url_path = parsed_url.path
-
-    for ext in SUPPORTED_FILE_EXTENSIONS:
-        if url_path.lower().endswith(f".{ext}"):
-            return AudioFileExtension(ext)
-
-    content_type = headers.get("content-type", "").lower()
-    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
-        return AudioFileExtension("mp3")
-    if "audio/wav" in content_type:
-        return AudioFileExtension("wav")
-    if "audio/mp4" in content_type:
-        return AudioFileExtension("mp4")
-
-    raise ValueError(
-        f"Unsupported audio format for URL: {url}. "
-        f"Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
-    )
-
-
-def download_audio_to_volume(
-    audio_file_url: str,
-) -> tuple[WhisperUniqFilename, AudioFileExtension]:
-    import requests
-    from fastapi import HTTPException
-
-    response = requests.head(audio_file_url, allow_redirects=True)
-    if response.status_code == 404:
-        raise HTTPException(status_code=404, detail="Audio file not found")
-
-    response = requests.get(audio_file_url, allow_redirects=True)
-    response.raise_for_status()
-
-    audio_suffix = detect_audio_format(audio_file_url, response.headers)
-    unique_filename = WhisperUniqFilename(f"{uuid.uuid4()}.{audio_suffix}")
-    file_path = f"{UPLOADS_PATH}/{unique_filename}"
-
-    with open(file_path, "wb") as f:
-        f.write(response.content)
-
-    upload_volume.commit()
-    return unique_filename, audio_suffix
-
-
-def pad_audio(audio_array, sample_rate: int = SAMPLERATE):
-    """Add 0.5s of silence if audio is shorter than the silence_padding window.
-
-    Whisper does not require this strictly, but aligning behavior with Parakeet
-    avoids edge-case crashes on extremely short inputs and makes comparisons easier.
-    """
-    import numpy as np
-
-    audio_duration = len(audio_array) / sample_rate
-    if audio_duration < VAD_CONFIG["silence_padding"]:
-        silence_samples = int(sample_rate * VAD_CONFIG["silence_padding"])
-        silence = np.zeros(silence_samples, dtype=np.float32)
-        return np.concatenate([audio_array, silence])
-    return audio_array
-
-
@app.cls(
    gpu="A10G",
    timeout=5 * MINUTES,
    scaledown_window=5 * MINUTES,
+    allow_concurrent_inputs=6,
    image=image,
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
+    volumes={MODELS_DIR: volume},
 )
-@modal.concurrent(max_inputs=10)
-class TranscriberWhisperLive:
-    """Live transcriber class for small audio segments (A10G).
-
-    Mirrors the Parakeet live class API but uses Faster-Whisper under the hood.
-    """
-
+class Transcriber:
    @modal.enter()
    def enter(self):
        import faster_whisper
@@ -187,200 +71,23 @@ class TranscriberWhisperLive:
            device=self.device,
            compute_type=MODEL_COMPUTE_TYPE,
            num_workers=MODEL_NUM_WORKERS,
-            download_root=CACHE_PATH,
+            download_root=MODELS_DIR,
            local_files_only=True,
        )
-        print(f"Model is on device: {self.device}")

    @modal.method()
    def transcribe_segment(
        self,
-        filename: str,
-        language: str = "en",
+        audio_data: str,
+        audio_suffix: str,
+        language: str,
    ):
-        """Transcribe a single uploaded audio file by filename."""
-        upload_volume.reload()
-
-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        with self.lock:
-            with NoStdStreams():
-                segments, _ = self.model.transcribe(
-                    file_path,
-                    language=language,
-                    beam_size=5,
-                    word_timestamps=True,
-                    vad_filter=True,
-                    vad_parameters={"min_silence_duration_ms": 500},
-                )
-
-        segments = list(segments)
-        text = "".join(segment.text for segment in segments).strip()
-        words = [
-            {
-                "word": word.word,
-                "start": round(float(word.start), 2),
-                "end": round(float(word.end), 2),
-            }
-            for segment in segments
-            for word in segment.words
-        ]
-
-        return {"text": text, "words": words}
-
-    @modal.method()
-    def transcribe_batch(
-        self,
-        filenames: list[str],
-        language: str = "en",
-    ):
-        """Transcribe multiple uploaded audio files and return per-file results."""
-        upload_volume.reload()
-
-        results = []
-        for filename in filenames:
-            file_path = f"{UPLOADS_PATH}/{filename}"
-            if not os.path.exists(file_path):
-                raise FileNotFoundError(f"Batch file not found: {file_path}")
-
-            with self.lock:
-                with NoStdStreams():
-                    segments, _ = self.model.transcribe(
-                        file_path,
-                        language=language,
-                        beam_size=5,
-                        word_timestamps=True,
-                        vad_filter=True,
-                        vad_parameters={"min_silence_duration_ms": 500},
-                    )
-
-            segments = list(segments)
-            text = "".join(seg.text for seg in segments).strip()
-            words = [
-                {
-                    "word": w.word,
-                    "start": round(float(w.start), 2),
-                    "end": round(float(w.end), 2),
-                }
-                for seg in segments
-                for w in seg.words
-            ]
-
-            results.append(
-                {
-                    "filename": filename,
-                    "text": text,
-                    "words": words,
-                }
-            )
-
-        return results
-
-
-@app.cls(
-    gpu="L40S",
-    timeout=15 * MINUTES,
-    image=image,
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-)
-class TranscriberWhisperFile:
-    """File transcriber for larger/longer audio, using VAD-driven batching (L40S)."""
-
-    @modal.enter()
-    def enter(self):
-        import faster_whisper
-        import torch
-        from silero_vad import load_silero_vad
-
-        self.lock = threading.Lock()
-        self.use_gpu = torch.cuda.is_available()
-        self.device = "cuda" if self.use_gpu else "cpu"
-        self.model = faster_whisper.WhisperModel(
-            MODEL_NAME,
-            device=self.device,
-            compute_type=MODEL_COMPUTE_TYPE,
-            num_workers=MODEL_NUM_WORKERS,
-            download_root=CACHE_PATH,
-            local_files_only=True,
-        )
-        self.vad_model = load_silero_vad(onnx=False)
-
-    @modal.method()
-    def transcribe_segment(
-        self, filename: str, timestamp_offset: float = 0.0, language: str = "en"
-    ):
-        import librosa
-        import numpy as np
-        from silero_vad import VADIterator
-
-        def vad_segments(
-            audio_array,
-            sample_rate: int = SAMPLERATE,
-            window_size: int = VAD_CONFIG["window_size"],
-        ) -> Generator[TimeSegment, None, None]:
-            """Generate speech segments as TimeSegment using Silero VAD."""
-            iterator = VADIterator(self.vad_model, sampling_rate=sample_rate)
-            start = None
-            for i in range(0, len(audio_array), window_size):
-                chunk = audio_array[i : i + window_size]
-                if len(chunk) < window_size:
-                    chunk = np.pad(
-                        chunk, (0, window_size - len(chunk)), mode="constant"
-                    )
-                speech = iterator(chunk)
-                if not speech:
-                    continue
-                if "start" in speech:
-                    start = speech["start"]
-                    continue
-                if "end" in speech and start is not None:
-                    end = speech["end"]
-                    yield TimeSegment(
-                        start / float(SAMPLERATE), end / float(SAMPLERATE)
-                    )
-                    start = None
-            iterator.reset_states()
-
-        upload_volume.reload()
-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        audio_array, _sr = librosa.load(file_path, sr=SAMPLERATE, mono=True)
-
-        # Batch segments up to ~30s windows by merging contiguous VAD segments
-        merged_batches: list[TimeSegment] = []
-        batch_start = None
-        batch_end = None
-        max_duration = VAD_CONFIG["batch_max_duration"]
-        for segment in vad_segments(audio_array):
-            seg_start, seg_end = segment.start, segment.end
-            if batch_start is None:
-                batch_start, batch_end = seg_start, seg_end
-                continue
-            if seg_end - batch_start <= max_duration:
-                batch_end = seg_end
-            else:
-                merged_batches.append(TimeSegment(batch_start, batch_end))
-                batch_start, batch_end = seg_start, seg_end
-        if batch_start is not None and batch_end is not None:
-            merged_batches.append(TimeSegment(batch_start, batch_end))
-
-        all_text = []
-        all_words = []
-
-        for segment in merged_batches:
-            start_time, end_time = segment.start, segment.end
-            s_idx = int(start_time * SAMPLERATE)
-            e_idx = int(end_time * SAMPLERATE)
-            segment = audio_array[s_idx:e_idx]
-            segment = pad_audio(segment, SAMPLERATE)
+        with tempfile.NamedTemporaryFile("wb+", suffix=f".{audio_suffix}") as fp:
+            fp.write(audio_data)

            with self.lock:
                segments, _ = self.model.transcribe(
-                    segment,
+                    fp.name,
                    language=language,
                    beam_size=5,
                    word_timestamps=True,
@@ -389,220 +96,66 @@ class TranscriberWhisperFile:
                )

            segments = list(segments)
-            text = "".join(seg.text for seg in segments).strip()
+            text = "".join(segment.text for segment in segments)
            words = [
-                {
-                    "word": w.word,
-                    "start": round(float(w.start) + start_time + timestamp_offset, 2),
-                    "end": round(float(w.end) + start_time + timestamp_offset, 2),
-                }
-                for seg in segments
-                for w in seg.words
+                {"word": word.word, "start": word.start, "end": word.end}
+                for segment in segments
+                for word in segment.words
            ]
-            if text:
-                all_text.append(text)
-            all_words.extend(words)

-        return {"text": " ".join(all_text), "words": all_words}
-
-
-def detect_audio_format(url: str, headers: dict) -> str:
-    from urllib.parse import urlparse
-
-    from fastapi import HTTPException
-
-    url_path = urlparse(url).path
-    for ext in SUPPORTED_FILE_EXTENSIONS:
-        if url_path.lower().endswith(f".{ext}"):
-            return ext
-
-    content_type = headers.get("content-type", "").lower()
-    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
-        return "mp3"
-    if "audio/wav" in content_type:
-        return "wav"
-    if "audio/mp4" in content_type:
-        return "mp4"
-
-    raise HTTPException(
-        status_code=400,
-        detail=(
-            f"Unsupported audio format for URL. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
-        ),
-    )
-
-
-def download_audio_to_volume(audio_file_url: str) -> tuple[str, str]:
-    import requests
-    from fastapi import HTTPException
-
-    response = requests.head(audio_file_url, allow_redirects=True)
-    if response.status_code == 404:
-        raise HTTPException(status_code=404, detail="Audio file not found")
-
-    response = requests.get(audio_file_url, allow_redirects=True)
-    response.raise_for_status()
-
-    audio_suffix = detect_audio_format(audio_file_url, response.headers)
-    unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
-    file_path = f"{UPLOADS_PATH}/{unique_filename}"
-
-    with open(file_path, "wb") as f:
-        f.write(response.content)
-
-    upload_volume.commit()
-    return unique_filename, audio_suffix
+            return {"text": text, "words": words}


@app.function(
    scaledown_window=60,
-    timeout=600,
+    timeout=60,
+    allow_concurrent_inputs=40,
    secrets=[
        modal.Secret.from_name("reflector-gpu"),
    ],
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-    image=image,
+    volumes={MODELS_DIR: volume},
 )
-@modal.concurrent(max_inputs=40)
@modal.asgi_app()
 def web():
-    from fastapi import (
-        Body,
-        Depends,
-        FastAPI,
-        Form,
-        HTTPException,
-        UploadFile,
-        status,
-    )
+    from fastapi import Body, Depends, FastAPI, HTTPException, UploadFile, status
    from fastapi.security import OAuth2PasswordBearer
+    from typing_extensions import Annotated

-    transcriber_live = TranscriberWhisperLive()
-    transcriber_file = TranscriberWhisperFile()
+    transcriber = Transcriber()

    app = FastAPI()

    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

-    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
-        if apikey == os.environ["REFLECTOR_GPU_APIKEY"]:
-            return
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid API key",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
+    supported_file_types = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]

-    class TranscriptResponse(dict):
-        pass
+    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
+        if apikey != os.environ["REFLECTOR_GPU_APIKEY"]:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid API key",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+    class TranscriptResponse(BaseModel):
+        result: dict

    @app.post("/v1/audio/transcriptions", dependencies=[Depends(apikey_auth)])
    def transcribe(
-        file: UploadFile = None,
-        files: list[UploadFile] | None = None,
-        model: str = Form(MODEL_NAME),
-        language: str = Form("en"),
-        batch: bool = Form(False),
-    ):
-        if not file and not files:
-            raise HTTPException(
-                status_code=400, detail="Either 'file' or 'files' parameter is required"
-            )
-        if batch and not files:
-            raise HTTPException(
-                status_code=400, detail="Batch transcription requires 'files'"
-            )
+        file: UploadFile,
+        model: str = "whisper-1",
+        language: Annotated[str, Body(...)] = "en",
+    ) -> TranscriptResponse:
+        audio_data = file.file.read()
+        audio_suffix = file.filename.split(".")[-1]
+        assert audio_suffix in supported_file_types

-        upload_files = [file] if file else files
-
-        uploaded_filenames: list[str] = []
-        for upload_file in upload_files:
-            audio_suffix = upload_file.filename.split(".")[-1]
-            if audio_suffix not in SUPPORTED_FILE_EXTENSIONS:
-                raise HTTPException(
-                    status_code=400,
-                    detail=(
-                        f"Unsupported audio format. Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
-                    ),
-                )
-
-            unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
-            file_path = f"{UPLOADS_PATH}/{unique_filename}"
-            with open(file_path, "wb") as f:
-                content = upload_file.file.read()
-                f.write(content)
-            uploaded_filenames.append(unique_filename)
-
-        upload_volume.commit()
-
-        try:
-            if batch and len(upload_files) > 1:
-                func = transcriber_live.transcribe_batch.spawn(
-                    filenames=uploaded_filenames,
-                    language=language,
-                )
-                results = func.get()
-                return {"results": results}
-
-            results = []
-            for filename in uploaded_filenames:
-                func = transcriber_live.transcribe_segment.spawn(
-                    filename=filename,
-                    language=language,
-                )
-                result = func.get()
-                result["filename"] = filename
-                results.append(result)
-
-            return {"results": results} if len(results) > 1 else results[0]
-        finally:
-            for filename in uploaded_filenames:
-                try:
-                    file_path = f"{UPLOADS_PATH}/{filename}"
-                    os.remove(file_path)
-                except Exception:
-                    pass
-            upload_volume.commit()
-
-    @app.post("/v1/audio/transcriptions-from-url", dependencies=[Depends(apikey_auth)])
-    def transcribe_from_url(
-        audio_file_url: str = Body(
-            ..., description="URL of the audio file to transcribe"
-        ),
-        model: str = Body(MODEL_NAME),
-        language: str = Body("en"),
-        timestamp_offset: float = Body(0.0),
-    ):
-        unique_filename, _audio_suffix = download_audio_to_volume(audio_file_url)
-        try:
-            func = transcriber_file.transcribe_segment.spawn(
-                filename=unique_filename,
-                timestamp_offset=timestamp_offset,
-                language=language,
-            )
-            result = func.get()
-            return result
-        finally:
-            try:
-                file_path = f"{UPLOADS_PATH}/{unique_filename}"
-                os.remove(file_path)
-                upload_volume.commit()
-            except Exception:
-                pass
+        func = transcriber.transcribe_segment.spawn(
+            audio_data=audio_data,
+            audio_suffix=audio_suffix,
+            language=language,
+        )
+        result = func.get()
+        return result

    return app
-
-
-class NoStdStreams:
-    def __init__(self):
-        self.devnull = open(os.devnull, "w")
-
-    def __enter__(self):
-        self._stdout, self._stderr = sys.stdout, sys.stderr
-        self._stdout.flush()
-        self._stderr.flush()
-        sys.stdout, sys.stderr = self.devnull, self.devnull
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        sys.stdout, sys.stderr = self._stdout, self._stderr
-        self.devnull.close()
--- a/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
+++ b/server/gpu/modal_deployments/reflector_transcriber_parakeet.py
@@ -1,658 +0,0 @@
-import logging
-import os
-import sys
-import threading
-import uuid
-from typing import Generator, Mapping, NamedTuple, NewType, TypedDict
-from urllib.parse import urlparse
-
-import modal
-
-MODEL_NAME = "nvidia/parakeet-tdt-0.6b-v2"
-SUPPORTED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
-SAMPLERATE = 16000
-UPLOADS_PATH = "/uploads"
-CACHE_PATH = "/cache"
-VAD_CONFIG = {
-    "batch_max_duration": 30.0,
-    "silence_padding": 0.5,
-    "window_size": 512,
-}
-
-ParakeetUniqFilename = NewType("ParakeetUniqFilename", str)
-AudioFileExtension = NewType("AudioFileExtension", str)
-
-
-class TimeSegment(NamedTuple):
-    """Represents a time segment with start and end times."""
-
-    start: float
-    end: float
-
-
-class AudioSegment(NamedTuple):
-    """Represents an audio segment with timing and audio data."""
-
-    start: float
-    end: float
-    audio: any
-
-
-class TranscriptResult(NamedTuple):
-    """Represents a transcription result with text and word timings."""
-
-    text: str
-    words: list["WordTiming"]
-
-
-class WordTiming(TypedDict):
-    """Represents a word with its timing information."""
-
-    word: str
-    start: float
-    end: float
-
-
-app = modal.App("reflector-transcriber-parakeet")
-
-# Volume for caching model weights
-model_cache = modal.Volume.from_name("parakeet-model-cache", create_if_missing=True)
-# Volume for temporary file uploads
-upload_volume = modal.Volume.from_name("parakeet-uploads", create_if_missing=True)
-
-image = (
-    modal.Image.from_registry(
-        "nvidia/cuda:12.8.0-cudnn-devel-ubuntu22.04", add_python="3.12"
-    )
-    .env(
-        {
-            "HF_HUB_ENABLE_HF_TRANSFER": "1",
-            "HF_HOME": "/cache",
-            "DEBIAN_FRONTEND": "noninteractive",
-            "CXX": "g++",
-            "CC": "g++",
-        }
-    )
-    .apt_install("ffmpeg")
-    .pip_install(
-        "hf_transfer==0.1.9",
-        "huggingface_hub[hf-xet]==0.31.2",
-        "nemo_toolkit[asr]==2.3.0",
-        "cuda-python==12.8.0",
-        "fastapi==0.115.12",
-        "numpy<2",
-        "librosa==0.10.1",
-        "requests",
-        "silero-vad==5.1.0",
-        "torch",
-    )
-    .entrypoint([])  # silence chatty logs by container on start
-)
-
-
-def detect_audio_format(url: str, headers: Mapping[str, str]) -> AudioFileExtension:
-    parsed_url = urlparse(url)
-    url_path = parsed_url.path
-
-    for ext in SUPPORTED_FILE_EXTENSIONS:
-        if url_path.lower().endswith(f".{ext}"):
-            return AudioFileExtension(ext)
-
-    content_type = headers.get("content-type", "").lower()
-    if "audio/mpeg" in content_type or "audio/mp3" in content_type:
-        return AudioFileExtension("mp3")
-    if "audio/wav" in content_type:
-        return AudioFileExtension("wav")
-    if "audio/mp4" in content_type:
-        return AudioFileExtension("mp4")
-
-    raise ValueError(
-        f"Unsupported audio format for URL: {url}. "
-        f"Supported extensions: {', '.join(SUPPORTED_FILE_EXTENSIONS)}"
-    )
-
-
-def download_audio_to_volume(
-    audio_file_url: str,
-) -> tuple[ParakeetUniqFilename, AudioFileExtension]:
-    import requests
-    from fastapi import HTTPException
-
-    response = requests.head(audio_file_url, allow_redirects=True)
-    if response.status_code == 404:
-        raise HTTPException(status_code=404, detail="Audio file not found")
-
-    response = requests.get(audio_file_url, allow_redirects=True)
-    response.raise_for_status()
-
-    audio_suffix = detect_audio_format(audio_file_url, response.headers)
-    unique_filename = ParakeetUniqFilename(f"{uuid.uuid4()}.{audio_suffix}")
-    file_path = f"{UPLOADS_PATH}/{unique_filename}"
-
-    with open(file_path, "wb") as f:
-        f.write(response.content)
-
-    upload_volume.commit()
-    return unique_filename, audio_suffix
-
-
-def pad_audio(audio_array, sample_rate: int = SAMPLERATE):
-    """Add 0.5 seconds of silence if audio is less than 500ms.
-
-    This is a workaround for a Parakeet bug where very short audio (<500ms) causes:
-    ValueError: `char_offsets`: [] and `processed_tokens`: [157, 834, 834, 841]
-    have to be of the same length
-
-    See: https://github.com/NVIDIA/NeMo/issues/8451
-    """
-    import numpy as np
-
-    audio_duration = len(audio_array) / sample_rate
-    if audio_duration < 0.5:
-        silence_samples = int(sample_rate * 0.5)
-        silence = np.zeros(silence_samples, dtype=np.float32)
-        return np.concatenate([audio_array, silence])
-    return audio_array
-
-
-@app.cls(
-    gpu="A10G",
-    timeout=600,
-    scaledown_window=300,
-    image=image,
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-    enable_memory_snapshot=True,
-    experimental_options={"enable_gpu_snapshot": True},
-)
-@modal.concurrent(max_inputs=10)
-class TranscriberParakeetLive:
-    @modal.enter(snap=True)
-    def enter(self):
-        import nemo.collections.asr as nemo_asr
-
-        logging.getLogger("nemo_logger").setLevel(logging.CRITICAL)
-
-        self.lock = threading.Lock()
-        self.model = nemo_asr.models.ASRModel.from_pretrained(model_name=MODEL_NAME)
-        device = next(self.model.parameters()).device
-        print(f"Model is on device: {device}")
-
-    @modal.method()
-    def transcribe_segment(
-        self,
-        filename: str,
-    ):
-        import librosa
-
-        upload_volume.reload()
-
-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
-        padded_audio = pad_audio(audio_array, sample_rate)
-
-        with self.lock:
-            with NoStdStreams():
-                (output,) = self.model.transcribe([padded_audio], timestamps=True)
-
-        text = output.text.strip()
-        words: list[WordTiming] = [
-            WordTiming(
-                # XXX the space added here is to match the output of whisper
-                # whisper add space to each words, while parakeet don't
-                word=word_info["word"] + " ",
-                start=round(word_info["start"], 2),
-                end=round(word_info["end"], 2),
-            )
-            for word_info in output.timestamp["word"]
-        ]
-
-        return {"text": text, "words": words}
-
-    @modal.method()
-    def transcribe_batch(
-        self,
-        filenames: list[str],
-    ):
-        import librosa
-
-        upload_volume.reload()
-
-        results = []
-        audio_arrays = []
-
-        # Load all audio files with padding
-        for filename in filenames:
-            file_path = f"{UPLOADS_PATH}/{filename}"
-            if not os.path.exists(file_path):
-                raise FileNotFoundError(f"Batch file not found: {file_path}")
-
-            audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
-            padded_audio = pad_audio(audio_array, sample_rate)
-            audio_arrays.append(padded_audio)
-
-        with self.lock:
-            with NoStdStreams():
-                outputs = self.model.transcribe(audio_arrays, timestamps=True)
-
-        # Process results for each file
-        for i, (filename, output) in enumerate(zip(filenames, outputs)):
-            text = output.text.strip()
-
-            words: list[WordTiming] = [
-                WordTiming(
-                    word=word_info["word"] + " ",
-                    start=round(word_info["start"], 2),
-                    end=round(word_info["end"], 2),
-                )
-                for word_info in output.timestamp["word"]
-            ]
-
-            results.append(
-                {
-                    "filename": filename,
-                    "text": text,
-                    "words": words,
-                }
-            )
-
-        return results
-
-
-# L40S class for file transcription (bigger files)
-@app.cls(
-    gpu="L40S",
-    timeout=900,
-    image=image,
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-    enable_memory_snapshot=True,
-    experimental_options={"enable_gpu_snapshot": True},
-)
-class TranscriberParakeetFile:
-    @modal.enter(snap=True)
-    def enter(self):
-        import nemo.collections.asr as nemo_asr
-        import torch
-        from silero_vad import load_silero_vad
-
-        logging.getLogger("nemo_logger").setLevel(logging.CRITICAL)
-
-        self.model = nemo_asr.models.ASRModel.from_pretrained(model_name=MODEL_NAME)
-        device = next(self.model.parameters()).device
-        print(f"Model is on device: {device}")
-
-        torch.set_num_threads(1)
-        self.vad_model = load_silero_vad(onnx=False)
-        print("Silero VAD initialized")
-
-    @modal.method()
-    def transcribe_segment(
-        self,
-        filename: str,
-        timestamp_offset: float = 0.0,
-    ):
-        import librosa
-        import numpy as np
-        from silero_vad import VADIterator
-
-        def load_and_convert_audio(file_path):
-            audio_array, sample_rate = librosa.load(file_path, sr=SAMPLERATE, mono=True)
-            return audio_array
-
-        def vad_segment_generator(
-            audio_array,
-        ) -> Generator[TimeSegment, None, None]:
-            """Generate speech segments using VAD with start/end sample indices"""
-            vad_iterator = VADIterator(self.vad_model, sampling_rate=SAMPLERATE)
-            window_size = VAD_CONFIG["window_size"]
-            start = None
-
-            for i in range(0, len(audio_array), window_size):
-                chunk = audio_array[i : i + window_size]
-                if len(chunk) < window_size:
-                    chunk = np.pad(
-                        chunk, (0, window_size - len(chunk)), mode="constant"
-                    )
-
-                speech_dict = vad_iterator(chunk)
-                if not speech_dict:
-                    continue
-
-                if "start" in speech_dict:
-                    start = speech_dict["start"]
-                    continue
-
-                if "end" in speech_dict and start is not None:
-                    end = speech_dict["end"]
-                    start_time = start / float(SAMPLERATE)
-                    end_time = end / float(SAMPLERATE)
-
-                    yield TimeSegment(start_time, end_time)
-                    start = None
-
-            vad_iterator.reset_states()
-
-        def batch_speech_segments(
-            segments: Generator[TimeSegment, None, None], max_duration: int
-        ) -> Generator[TimeSegment, None, None]:
-            """
-            Input segments:
-              [0-2] [3-5] [6-8] [10-11] [12-15] [17-19] [20-22]
-
-                                  ↓ (max_duration=10)
-
-              Output batches:
-              [0-8]           [10-19]          [20-22]
-
-            Note: silences are kept for better transcription, previous implementation was
-            passing segments separatly, but the output was less accurate.
-            """
-            batch_start_time = None
-            batch_end_time = None
-
-            for segment in segments:
-                start_time, end_time = segment.start, segment.end
-                if batch_start_time is None or batch_end_time is None:
-                    batch_start_time = start_time
-                    batch_end_time = end_time
-                    continue
-
-                total_duration = end_time - batch_start_time
-
-                if total_duration <= max_duration:
-                    batch_end_time = end_time
-                    continue
-
-                yield TimeSegment(batch_start_time, batch_end_time)
-                batch_start_time = start_time
-                batch_end_time = end_time
-
-            if batch_start_time is None or batch_end_time is None:
-                return
-
-            yield TimeSegment(batch_start_time, batch_end_time)
-
-        def batch_segment_to_audio_segment(
-            segments: Generator[TimeSegment, None, None],
-            audio_array,
-        ) -> Generator[AudioSegment, None, None]:
-            """Extract audio segments and apply padding for Parakeet compatibility.
-
-            Uses pad_audio to ensure segments are at least 0.5s long, preventing
-            Parakeet crashes. This padding may cause slight timing overlaps between
-            segments, which are corrected by enforce_word_timing_constraints.
-            """
-            for segment in segments:
-                start_time, end_time = segment.start, segment.end
-                start_sample = int(start_time * SAMPLERATE)
-                end_sample = int(end_time * SAMPLERATE)
-                audio_segment = audio_array[start_sample:end_sample]
-
-                padded_segment = pad_audio(audio_segment, SAMPLERATE)
-
-                yield AudioSegment(start_time, end_time, padded_segment)
-
-        def transcribe_batch(model, audio_segments: list) -> list:
-            with NoStdStreams():
-                outputs = model.transcribe(audio_segments, timestamps=True)
-            return outputs
-
-        def enforce_word_timing_constraints(
-            words: list[WordTiming],
-        ) -> list[WordTiming]:
-            """Enforce that word end times don't exceed the start time of the next word.
-
-            Due to silence padding added in batch_segment_to_audio_segment for better
-            transcription accuracy, word timings from different segments may overlap.
-            This function ensures there are no overlaps by adjusting end times.
-            """
-            if len(words) <= 1:
-                return words
-
-            enforced_words = []
-            for i, word in enumerate(words):
-                enforced_word = word.copy()
-
-                if i < len(words) - 1:
-                    next_start = words[i + 1]["start"]
-                    if enforced_word["end"] > next_start:
-                        enforced_word["end"] = next_start
-
-                enforced_words.append(enforced_word)
-
-            return enforced_words
-
-        def emit_results(
-            results: list,
-            segments_info: list[AudioSegment],
-        ) -> Generator[TranscriptResult, None, None]:
-            """Yield transcribed text and word timings from model output, adjusting timestamps to absolute positions."""
-            for i, (output, segment) in enumerate(zip(results, segments_info)):
-                start_time, end_time = segment.start, segment.end
-                text = output.text.strip()
-                words: list[WordTiming] = [
-                    WordTiming(
-                        word=word_info["word"] + " ",
-                        start=round(
-                            word_info["start"] + start_time + timestamp_offset, 2
-                        ),
-                        end=round(word_info["end"] + start_time + timestamp_offset, 2),
-                    )
-                    for word_info in output.timestamp["word"]
-                ]
-
-                yield TranscriptResult(text, words)
-
-        upload_volume.reload()
-
-        file_path = f"{UPLOADS_PATH}/{filename}"
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        audio_array = load_and_convert_audio(file_path)
-        total_duration = len(audio_array) / float(SAMPLERATE)
-
-        all_text_parts: list[str] = []
-        all_words: list[WordTiming] = []
-
-        raw_segments = vad_segment_generator(audio_array)
-        speech_segments = batch_speech_segments(
-            raw_segments,
-            VAD_CONFIG["batch_max_duration"],
-        )
-        audio_segments = batch_segment_to_audio_segment(speech_segments, audio_array)
-
-        for batch in audio_segments:
-            audio_segment = batch.audio
-            results = transcribe_batch(self.model, [audio_segment])
-
-            for result in emit_results(
-                results,
-                [batch],
-            ):
-                if not result.text:
-                    continue
-                all_text_parts.append(result.text)
-                all_words.extend(result.words)
-
-        all_words = enforce_word_timing_constraints(all_words)
-
-        combined_text = " ".join(all_text_parts)
-        return {"text": combined_text, "words": all_words}
-
-
-@app.function(
-    scaledown_window=60,
-    timeout=600,
-    secrets=[
-        modal.Secret.from_name("reflector-gpu"),
-    ],
-    volumes={CACHE_PATH: model_cache, UPLOADS_PATH: upload_volume},
-    image=image,
-)
-@modal.concurrent(max_inputs=40)
-@modal.asgi_app()
-def web():
-    import os
-    import uuid
-
-    from fastapi import (
-        Body,
-        Depends,
-        FastAPI,
-        Form,
-        HTTPException,
-        UploadFile,
-        status,
-    )
-    from fastapi.security import OAuth2PasswordBearer
-    from pydantic import BaseModel
-
-    transcriber_live = TranscriberParakeetLive()
-    transcriber_file = TranscriberParakeetFile()
-
-    app = FastAPI()
-
-    oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-    def apikey_auth(apikey: str = Depends(oauth2_scheme)):
-        if apikey == os.environ["REFLECTOR_GPU_APIKEY"]:
-            return
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid API key",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
-    class TranscriptResponse(BaseModel):
-        result: dict
-
-    @app.post("/v1/audio/transcriptions", dependencies=[Depends(apikey_auth)])
-    def transcribe(
-        file: UploadFile = None,
-        files: list[UploadFile] | None = None,
-        model: str = Form(MODEL_NAME),
-        language: str = Form("en"),
-        batch: bool = Form(False),
-    ):
-        # Parakeet only supports English
-        if language != "en":
-            raise HTTPException(
-                status_code=400,
-                detail=f"Parakeet model only supports English. Got language='{language}'",
-            )
-        # Handle both single file and multiple files
-        if not file and not files:
-            raise HTTPException(
-                status_code=400, detail="Either 'file' or 'files' parameter is required"
-            )
-        if batch and not files:
-            raise HTTPException(
-                status_code=400, detail="Batch transcription requires 'files'"
-            )
-
-        upload_files = [file] if file else files
-
-        # Upload files to volume
-        uploaded_filenames = []
-        for upload_file in upload_files:
-            audio_suffix = upload_file.filename.split(".")[-1]
-            assert audio_suffix in SUPPORTED_FILE_EXTENSIONS
-
-            # Generate unique filename
-            unique_filename = f"{uuid.uuid4()}.{audio_suffix}"
-            file_path = f"{UPLOADS_PATH}/{unique_filename}"
-
-            print(f"Writing file to: {file_path}")
-            with open(file_path, "wb") as f:
-                content = upload_file.file.read()
-                f.write(content)
-
-            uploaded_filenames.append(unique_filename)
-
-        upload_volume.commit()
-
-        try:
-            # Use A10G live transcriber for per-file transcription
-            if batch and len(upload_files) > 1:
-                # Use batch transcription
-                func = transcriber_live.transcribe_batch.spawn(
-                    filenames=uploaded_filenames,
-                )
-                results = func.get()
-                return {"results": results}
-
-            # Per-file transcription
-            results = []
-            for filename in uploaded_filenames:
-                func = transcriber_live.transcribe_segment.spawn(
-                    filename=filename,
-                )
-                result = func.get()
-                result["filename"] = filename
-                results.append(result)
-
-            return {"results": results} if len(results) > 1 else results[0]
-
-        finally:
-            for filename in uploaded_filenames:
-                try:
-                    file_path = f"{UPLOADS_PATH}/{filename}"
-                    print(f"Deleting file: {file_path}")
-                    os.remove(file_path)
-                except Exception as e:
-                    print(f"Error deleting {filename}: {e}")
-
-            upload_volume.commit()
-
-    @app.post("/v1/audio/transcriptions-from-url", dependencies=[Depends(apikey_auth)])
-    def transcribe_from_url(
-        audio_file_url: str = Body(
-            ..., description="URL of the audio file to transcribe"
-        ),
-        model: str = Body(MODEL_NAME),
-        language: str = Body("en", description="Language code (only 'en' supported)"),
-        timestamp_offset: float = Body(0.0),
-    ):
-        # Parakeet only supports English
-        if language != "en":
-            raise HTTPException(
-                status_code=400,
-                detail=f"Parakeet model only supports English. Got language='{language}'",
-            )
-        unique_filename, audio_suffix = download_audio_to_volume(audio_file_url)
-
-        try:
-            func = transcriber_file.transcribe_segment.spawn(
-                filename=unique_filename,
-                timestamp_offset=timestamp_offset,
-            )
-            result = func.get()
-            return result
-        finally:
-            try:
-                file_path = f"{UPLOADS_PATH}/{unique_filename}"
-                print(f"Deleting file: {file_path}")
-                os.remove(file_path)
-                upload_volume.commit()
-            except Exception as e:
-                print(f"Error cleaning up {unique_filename}: {e}")
-
-    return app
-
-
-class NoStdStreams:
-    def __init__(self):
-        self.devnull = open(os.devnull, "w")
-
-    def __enter__(self):
-        self._stdout, self._stderr = sys.stdout, sys.stderr
-        self._stdout.flush()
-        self._stderr.flush()
-        sys.stdout, sys.stderr = self.devnull, self.devnull
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        sys.stdout, sys.stderr = self._stdout, self._stderr
-        self.devnull.close()
--- a/server/gpu/modal_deployments/reflector_vllm_hermes3.py
+++ b/server/gpu/modal_deployments/reflector_vllm_hermes3.py
@@ -0,0 +1,171 @@
+# # Run an OpenAI-Compatible vLLM Server
+
+import modal
+
+MODELS_DIR = "/llamas"
+MODEL_NAME = "NousResearch/Hermes-3-Llama-3.1-8B"
+N_GPU = 1
+
+
+def download_llm():
+    from huggingface_hub import snapshot_download
+
+    print("Downloading LLM model")
+    snapshot_download(
+        MODEL_NAME,
+        local_dir=f"{MODELS_DIR}/{MODEL_NAME}",
+        ignore_patterns=[
+            "*.pt",
+            "*.bin",
+            "*.pth",
+            "original/*",
+        ],  # Ensure safetensors
+    )
+    print("LLM model downloaded")
+
+
+def move_cache():
+    from transformers.utils import move_cache as transformers_move_cache
+
+    transformers_move_cache()
+
+
+vllm_image = (
+    modal.Image.debian_slim(python_version="3.10")
+    .pip_install("vllm==0.5.3post1")
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
+    .pip_install(
+        # "accelerate==0.34.2",
+        "einops==0.8.0",
+        "hf-transfer~=0.1",
+    )
+    .run_function(download_llm)
+    .run_function(move_cache)
+    .pip_install(
+        "bitsandbytes>=0.42.9",
+    )
+)
+
+app = modal.App("reflector-vllm-hermes3")
+
+
+@app.function(
+    image=vllm_image,
+    gpu=modal.gpu.A100(count=N_GPU, size="40GB"),
+    timeout=60 * 5,
+    scaledown_window=60 * 5,
+    allow_concurrent_inputs=100,
+    secrets=[
+        modal.Secret.from_name("reflector-gpu"),
+    ],
+)
+@modal.asgi_app()
+def serve():
+    import os
+
+    import fastapi
+    import vllm.entrypoints.openai.api_server as api_server
+    from vllm.engine.arg_utils import AsyncEngineArgs
+    from vllm.engine.async_llm_engine import AsyncLLMEngine
+    from vllm.entrypoints.logger import RequestLogger
+    from vllm.entrypoints.openai.serving_chat import OpenAIServingChat
+    from vllm.entrypoints.openai.serving_completion import OpenAIServingCompletion
+    from vllm.usage.usage_lib import UsageContext
+
+    TOKEN = os.environ["REFLECTOR_GPU_APIKEY"]
+
+    # create a fastAPI app that uses vLLM's OpenAI-compatible router
+    web_app = fastapi.FastAPI(
+        title=f"OpenAI-compatible {MODEL_NAME} server",
+        description="Run an OpenAI-compatible LLM server with vLLM on modal.com",
+        version="0.0.1",
+        docs_url="/docs",
+    )
+
+    # security: CORS middleware for external requests
+    http_bearer = fastapi.security.HTTPBearer(
+        scheme_name="Bearer Token",
+        description="See code for authentication details.",
+    )
+    web_app.add_middleware(
+        fastapi.middleware.cors.CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # security: inject dependency on authed routes
+    async def is_authenticated(api_key: str = fastapi.Security(http_bearer)):
+        if api_key.credentials != TOKEN:
+            raise fastapi.HTTPException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid authentication credentials",
+            )
+        return {"username": "authenticated_user"}
+
+    router = fastapi.APIRouter(dependencies=[fastapi.Depends(is_authenticated)])
+
+    # wrap vllm's router in auth router
+    router.include_router(api_server.router)
+    # add authed vllm to our fastAPI app
+    web_app.include_router(router)
+
+    engine_args = AsyncEngineArgs(
+        model=MODELS_DIR + "/" + MODEL_NAME,
+        tensor_parallel_size=N_GPU,
+        gpu_memory_utilization=0.90,
+        # max_model_len=8096,
+        enforce_eager=False,  # capture the graph for faster inference, but slower cold starts (30s > 20s)
+        # --- 4 bits load
+        # quantization="bitsandbytes",
+        # load_format="bitsandbytes",
+    )
+
+    engine = AsyncLLMEngine.from_engine_args(
+        engine_args, usage_context=UsageContext.OPENAI_API_SERVER
+    )
+
+    model_config = get_model_config(engine)
+
+    request_logger = RequestLogger(max_log_len=2048)
+
+    api_server.openai_serving_chat = OpenAIServingChat(
+        engine,
+        model_config=model_config,
+        served_model_names=[MODEL_NAME],
+        chat_template=None,
+        response_role="assistant",
+        lora_modules=[],
+        prompt_adapters=[],
+        request_logger=request_logger,
+    )
+    api_server.openai_serving_completion = OpenAIServingCompletion(
+        engine,
+        model_config=model_config,
+        served_model_names=[MODEL_NAME],
+        lora_modules=[],
+        prompt_adapters=[],
+        request_logger=request_logger,
+    )
+
+    return web_app
+
+
+def get_model_config(engine):
+    import asyncio
+
+    try:  # adapted from vLLM source -- https://github.com/vllm-project/vllm/blob/507ef787d85dec24490069ffceacbd6b161f4f72/vllm/entrypoints/openai/api_server.py#L235C1-L247C1
+        event_loop = asyncio.get_running_loop()
+    except RuntimeError:
+        event_loop = None
+
+    if event_loop is not None and event_loop.is_running():
+        # If the current is instanced by Ray Serve,
+        # there is already a running event loop
+        model_config = event_loop.run_until_complete(engine.get_model_config())
+    else:
+        # When using single vLLM without engine_use_ray
+        model_config = asyncio.run(engine.get_model_config())
+
+    return model_config
--- a/server/migration.load
+++ b/server/migration.load
@@ -0,0 +1,16 @@
+LOAD DATABASE
+     FROM sqlite:///app/reflector.sqlite3
+     INTO pgsql://reflector:reflector@postgres:5432/reflector
+WITH
+    include drop,
+    create tables,
+    create indexes,
+    reset sequences,
+    preserve index names,
+    prefetch rows = 10
+SET
+    work_mem to '512MB',
+    maintenance_work_mem to '1024MB'
+CAST
+    column transcript.duration to float using (lambda (val) (when val (format nil "~f" val)))
+;
--- a/server/migrations/README
+++ b/server/migrations/README
@@ -1,3 +1 @@
-Generic single-database configuration.
-
-Both data migrations and schema migrations must be in migrations.
+Generic single-database configuration.
--- a/server/migrations/env.py
+++ b/server/migrations/env.py
@@ -1,10 +1,9 @@
 from logging.config import fileConfig

 from alembic import context
-from sqlalchemy import engine_from_config, pool
-
 from reflector.db import metadata
 from reflector.settings import settings
+from sqlalchemy import engine_from_config, pool

 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
--- a/server/migrations/versions/0194f65cd6d3_add_webhook_fields_to_rooms.py
+++ b/server/migrations/versions/0194f65cd6d3_add_webhook_fields_to_rooms.py
@@ -1,36 +0,0 @@
-"""Add webhook fields to rooms
-
-Revision ID: 0194f65cd6d3
-Revises: 5a8907fd1d78
-Create Date: 2025-08-27 09:03:19.610995
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "0194f65cd6d3"
-down_revision: Union[str, None] = "5a8907fd1d78"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.add_column(sa.Column("webhook_url", sa.String(), nullable=True))
-        batch_op.add_column(sa.Column("webhook_secret", sa.String(), nullable=True))
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.drop_column("webhook_secret")
-        batch_op.drop_column("webhook_url")
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/082fa608201c_add_room_background_information.py
+++ b/server/migrations/versions/082fa608201c_add_room_background_information.py
@@ -0,0 +1,26 @@
+"""add_room_background_information
+
+Revision ID: 082fa608201c
+Revises: b7df9609542c
+Create Date: 2025-07-29 01:41:37.912195
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '082fa608201c'
+down_revision: Union[str, None] = 'b7df9609542c'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column('room', sa.Column('background_information', sa.Text(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column('room', 'background_information')
--- a/server/migrations/versions/0925da921477_unique_room_names.py
+++ b/server/migrations/versions/0925da921477_unique_room_names.py
@@ -8,6 +8,7 @@ Create Date: 2024-09-24 16:12:56.944133

 from typing import Sequence, Union

+import sqlalchemy as sa
 from alembic import op

 # revision identifiers, used by Alembic.
--- a/server/migrations/versions/0ab2d7ffaa16_add_long_summary_to_search_vector.py
+++ b/server/migrations/versions/0ab2d7ffaa16_add_long_summary_to_search_vector.py
@@ -1,64 +0,0 @@
-"""add_long_summary_to_search_vector
-
-Revision ID: 0ab2d7ffaa16
-Revises: b1c33bd09963
-Create Date: 2025-08-15 13:27:52.680211
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "0ab2d7ffaa16"
-down_revision: Union[str, None] = "b1c33bd09963"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # Drop the existing search vector column and index
-    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
-    op.drop_column("transcript", "search_vector_en")
-
-    # Recreate the search vector column with long_summary included
-    op.execute("""
-        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
-        GENERATED ALWAYS AS (
-            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
-            setweight(to_tsvector('english', coalesce(long_summary, '')), 'B') ||
-            setweight(to_tsvector('english', coalesce(webvtt, '')), 'C')
-        ) STORED
-    """)
-
-    # Recreate the GIN index for the search vector
-    op.create_index(
-        "idx_transcript_search_vector_en",
-        "transcript",
-        ["search_vector_en"],
-        postgresql_using="gin",
-    )
-
-
-def downgrade() -> None:
-    # Drop the updated search vector column and index
-    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
-    op.drop_column("transcript", "search_vector_en")
-
-    # Recreate the original search vector column without long_summary
-    op.execute("""
-        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
-        GENERATED ALWAYS AS (
-            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
-            setweight(to_tsvector('english', coalesce(webvtt, '')), 'B')
-        ) STORED
-    """)
-
-    # Recreate the GIN index for the search vector
-    op.create_index(
-        "idx_transcript_search_vector_en",
-        "transcript",
-        ["search_vector_en"],
-        postgresql_using="gin",
-    )
--- a/server/migrations/versions/0bc0f3ff0111_add_webvtt_field_to_transcript.py
+++ b/server/migrations/versions/0bc0f3ff0111_add_webvtt_field_to_transcript.py
@@ -1,25 +0,0 @@
-"""add_webvtt_field_to_transcript
-
-Revision ID: 0bc0f3ff0111
-Revises: b7df9609542c
-Create Date: 2025-08-05 19:36:41.740957
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-revision: str = "0bc0f3ff0111"
-down_revision: Union[str, None] = "b7df9609542c"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    op.add_column("transcript", sa.Column("webvtt", sa.Text(), nullable=True))
-
-
-def downgrade() -> None:
-    op.drop_column("transcript", "webvtt")
--- a/server/migrations/versions/0ce521cda2ee_remove_user_id_from_meeting_table.py
+++ b/server/migrations/versions/0ce521cda2ee_remove_user_id_from_meeting_table.py
@@ -1,36 +0,0 @@
-"""remove user_id from meeting table
-
-Revision ID: 0ce521cda2ee
-Revises: 6dec9fb5b46c
-Create Date: 2025-09-10 12:40:55.688899
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "0ce521cda2ee"
-down_revision: Union[str, None] = "6dec9fb5b46c"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.drop_column("user_id")
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.add_column(
-            sa.Column("user_id", sa.VARCHAR(), autoincrement=False, nullable=True)
-        )
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/0fea6d96b096_add_share_mode.py
+++ b/server/migrations/versions/0fea6d96b096_add_share_mode.py
@@ -5,11 +5,11 @@ Revises: f819277e5169
 Create Date: 2023-11-07 11:12:21.614198

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "0fea6d96b096"
--- a/server/migrations/versions/116b2f287eab_add_full_text_search.py
+++ b/server/migrations/versions/116b2f287eab_add_full_text_search.py
@@ -1,46 +0,0 @@
-"""add_full_text_search
-
-Revision ID: 116b2f287eab
-Revises: 0bc0f3ff0111
-Create Date: 2025-08-07 11:27:38.473517
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-revision: str = "116b2f287eab"
-down_revision: Union[str, None] = "0bc0f3ff0111"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-    if conn.dialect.name != "postgresql":
-        return
-
-    op.execute("""
-        ALTER TABLE transcript ADD COLUMN search_vector_en tsvector
-        GENERATED ALWAYS AS (
-            setweight(to_tsvector('english', coalesce(title, '')), 'A') ||
-            setweight(to_tsvector('english', coalesce(webvtt, '')), 'B')
-        ) STORED
-    """)
-
-    op.create_index(
-        "idx_transcript_search_vector_en",
-        "transcript",
-        ["search_vector_en"],
-        postgresql_using="gin",
-    )
-
-
-def downgrade() -> None:
-    conn = op.get_bind()
-    if conn.dialect.name != "postgresql":
-        return
-
-    op.drop_index("idx_transcript_search_vector_en", table_name="transcript")
-    op.drop_column("transcript", "search_vector_en")
--- a/server/migrations/versions/125031f7cb78_participants.py
+++ b/server/migrations/versions/125031f7cb78_participants.py
@@ -5,26 +5,26 @@ Revises: 0fea6d96b096
 Create Date: 2023-11-30 15:56:03.341466

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
-revision: str = "125031f7cb78"
-down_revision: Union[str, None] = "0fea6d96b096"
+revision: str = '125031f7cb78'
+down_revision: Union[str, None] = '0fea6d96b096'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None


 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column("transcript", sa.Column("participants", sa.JSON(), nullable=True))
+    op.add_column('transcript', sa.Column('participants', sa.JSON(), nullable=True))
    # ### end Alembic commands ###


 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column("transcript", "participants")
+    op.drop_column('transcript', 'participants')
    # ### end Alembic commands ###
--- a/server/migrations/versions/20250617140003_add_meeting_consent_table.py
+++ b/server/migrations/versions/20250617140003_add_meeting_consent_table.py
@@ -5,7 +5,6 @@ Revises: f819277e5169
 Create Date: 2025-06-17 14:00:03.000000

 """
-
 from typing import Sequence, Union

 import sqlalchemy as sa
@@ -20,16 +19,16 @@ depends_on: Union[str, Sequence[str], None] = None

 def upgrade() -> None:
    op.create_table(
-        "meeting_consent",
-        sa.Column("id", sa.String(), nullable=False),
-        sa.Column("meeting_id", sa.String(), nullable=False),
-        sa.Column("user_id", sa.String(), nullable=True),
-        sa.Column("consent_given", sa.Boolean(), nullable=False),
-        sa.Column("consent_timestamp", sa.DateTime(), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-        sa.ForeignKeyConstraint(["meeting_id"], ["meeting.id"]),
+        'meeting_consent',
+        sa.Column('id', sa.String(), nullable=False),
+        sa.Column('meeting_id', sa.String(), nullable=False),
+        sa.Column('user_id', sa.String(), nullable=True),
+        sa.Column('consent_given', sa.Boolean(), nullable=False),
+        sa.Column('consent_timestamp', sa.DateTime(), nullable=False),
+        sa.PrimaryKeyConstraint('id'),
+        sa.ForeignKeyConstraint(['meeting_id'], ['meeting.id']),
    )


 def downgrade() -> None:
-    op.drop_table("meeting_consent")
+    op.drop_table('meeting_consent')
--- a/server/migrations/versions/20250618140000_add_audio_deleted_field_to_transcript.py
+++ b/server/migrations/versions/20250618140000_add_audio_deleted_field_to_transcript.py
@@ -5,7 +5,6 @@ Revises: 20250617140003
 Create Date: 2025-06-18 14:00:00.000000

 """
-
 from typing import Sequence, Union

 import sqlalchemy as sa
@@ -23,4 +22,4 @@ def upgrade() -> None:


 def downgrade() -> None:
-    op.drop_column("transcript", "audio_deleted")
+    op.drop_column("transcript", "audio_deleted")
--- a/server/migrations/versions/2ae3db106d4e_clean_up_orphaned_room_id_references_in_.py
+++ b/server/migrations/versions/2ae3db106d4e_clean_up_orphaned_room_id_references_in_.py
@@ -1,32 +0,0 @@
-"""clean up orphaned room_id references in meeting table
-
-Revision ID: 2ae3db106d4e
-Revises: def1b5867d4c
-Create Date: 2025-09-11 10:35:15.759967
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "2ae3db106d4e"
-down_revision: Union[str, None] = "def1b5867d4c"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # Set room_id to NULL for meetings that reference non-existent rooms
-    op.execute("""
-        UPDATE meeting
-        SET room_id = NULL
-        WHERE room_id IS NOT NULL
-          AND room_id NOT IN (SELECT id FROM room WHERE id IS NOT NULL)
-    """)
-
-
-def downgrade() -> None:
-    # Cannot restore orphaned references - no operation needed
-    pass
--- a/server/migrations/versions/2cf0b60a9d34_fix_transcript_duration_type.py
+++ b/server/migrations/versions/2cf0b60a9d34_fix_transcript_duration_type.py
@@ -5,40 +5,36 @@ Revises: ccd68dc784ff
 Create Date: 2025-07-15 16:53:40.397394

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
-revision: str = "2cf0b60a9d34"
-down_revision: Union[str, None] = "ccd68dc784ff"
+revision: str = '2cf0b60a9d34'
+down_revision: Union[str, None] = 'ccd68dc784ff'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None


 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("transcript", schema=None) as batch_op:
-        batch_op.alter_column(
-            "duration",
-            existing_type=sa.INTEGER(),
-            type_=sa.Float(),
-            existing_nullable=True,
-        )
+    with op.batch_alter_table('transcript', schema=None) as batch_op:
+        batch_op.alter_column('duration',
+               existing_type=sa.INTEGER(),
+               type_=sa.Float(),
+               existing_nullable=True)

    # ### end Alembic commands ###


 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("transcript", schema=None) as batch_op:
-        batch_op.alter_column(
-            "duration",
-            existing_type=sa.Float(),
-            type_=sa.INTEGER(),
-            existing_nullable=True,
-        )
+    with op.batch_alter_table('transcript', schema=None) as batch_op:
+        batch_op.alter_column('duration',
+               existing_type=sa.Float(),
+               type_=sa.INTEGER(),
+               existing_nullable=True)

    # ### end Alembic commands ###
--- a/server/migrations/versions/38a927dcb099_rename_back_text_to_transcript.py
+++ b/server/migrations/versions/38a927dcb099_rename_back_text_to_transcript.py
@@ -5,17 +5,17 @@ Revises: 9920ecfe2735
 Create Date: 2023-11-02 19:53:09.116240

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import table, column
 from sqlalchemy import select
-from sqlalchemy.sql import column, table
+

 # revision identifiers, used by Alembic.
-revision: str = "38a927dcb099"
-down_revision: Union[str, None] = "9920ecfe2735"
+revision: str = '38a927dcb099'
+down_revision: Union[str, None] = '9920ecfe2735'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None

--- a/server/migrations/versions/4814901632bc_fix_duration.py
+++ b/server/migrations/versions/4814901632bc_fix_duration.py
@@ -5,13 +5,13 @@ Revises: 38a927dcb099
 Create Date: 2023-11-10 18:12:17.886522

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import table, column
 from sqlalchemy import select
-from sqlalchemy.sql import column, table
+

 # revision identifiers, used by Alembic.
 revision: str = "4814901632bc"
@@ -24,10 +24,8 @@ def upgrade() -> None:
    # for all the transcripts, calculate the duration from the mp3
    # and update the duration column
    from pathlib import Path
-
-    import av
-
    from reflector.settings import settings
+    import av

    bind = op.get_bind()
    transcript = table(
--- a/server/migrations/versions/543ed284d69a_init.py
+++ b/server/migrations/versions/543ed284d69a_init.py
@@ -5,11 +5,14 @@ Revises:
 Create Date: 2023-08-29 10:54:45.142974

 """
-
 from typing import Sequence, Union

+from alembic import op
+import sqlalchemy as sa
+
+
 # revision identifiers, used by Alembic.
-revision: str = "543ed284d69a"
+revision: str = '543ed284d69a'
 down_revision: Union[str, None] = None
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
--- a/server/migrations/versions/5a8907fd1d78_add_cascade_delete_to_meeting_consent_.py
+++ b/server/migrations/versions/5a8907fd1d78_add_cascade_delete_to_meeting_consent_.py
@@ -1,50 +0,0 @@
-"""add cascade delete to meeting consent foreign key
-
-Revision ID: 5a8907fd1d78
-Revises: 0ab2d7ffaa16
-Create Date: 2025-08-26 17:26:50.945491
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "5a8907fd1d78"
-down_revision: Union[str, None] = "0ab2d7ffaa16"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
-        batch_op.drop_constraint(
-            batch_op.f("meeting_consent_meeting_id_fkey"), type_="foreignkey"
-        )
-        batch_op.create_foreign_key(
-            batch_op.f("meeting_consent_meeting_id_fkey"),
-            "meeting",
-            ["meeting_id"],
-            ["id"],
-            ondelete="CASCADE",
-        )
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
-        batch_op.drop_constraint(
-            batch_op.f("meeting_consent_meeting_id_fkey"), type_="foreignkey"
-        )
-        batch_op.create_foreign_key(
-            batch_op.f("meeting_consent_meeting_id_fkey"),
-            "meeting",
-            ["meeting_id"],
-            ["id"],
-        )
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/61882a919591_webhook_url_and_secret_null_by_default.py
+++ b/server/migrations/versions/61882a919591_webhook_url_and_secret_null_by_default.py
@@ -1,28 +0,0 @@
-"""webhook url and secret null by default
-
-
-Revision ID: 61882a919591
-Revises: 0194f65cd6d3
-Create Date: 2025-08-29 11:46:36.738091
-
-"""
-
-from typing import Sequence, Union
-
-# revision identifiers, used by Alembic.
-revision: str = "61882a919591"
-down_revision: Union[str, None] = "0194f65cd6d3"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###
--- a/server/migrations/versions/62dea3db63a5_add_room_options.py
+++ b/server/migrations/versions/62dea3db63a5_add_room_options.py
@@ -8,8 +8,9 @@ Create Date: 2025-06-27 09:04:21.006823

 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "62dea3db63a5"
@@ -32,7 +33,7 @@ def upgrade() -> None:
        sa.Column("user_id", sa.String(), nullable=True),
        sa.Column("room_id", sa.String(), nullable=True),
        sa.Column(
-            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("0"), nullable=False
        ),
        sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
        sa.Column(
@@ -53,15 +54,12 @@ def upgrade() -> None:
        sa.Column("user_id", sa.String(), nullable=False),
        sa.Column("created_at", sa.DateTime(), nullable=False),
        sa.Column(
-            "zulip_auto_post",
-            sa.Boolean(),
-            server_default=sa.text("false"),
-            nullable=False,
+            "zulip_auto_post", sa.Boolean(), server_default=sa.text("0"), nullable=False
        ),
        sa.Column("zulip_stream", sa.String(), nullable=True),
        sa.Column("zulip_topic", sa.String(), nullable=True),
        sa.Column(
-            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("0"), nullable=False
        ),
        sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
        sa.Column(
--- a/server/migrations/versions/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py
+++ b/server/migrations/versions/6dec9fb5b46c_make_meeting_room_id_required_and_add_.py
@@ -1,38 +0,0 @@
-"""make meeting room_id required and add foreign key
-
-Revision ID: 6dec9fb5b46c
-Revises: 61882a919591
-Create Date: 2025-09-10 10:47:06.006819
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "6dec9fb5b46c"
-down_revision: Union[str, None] = "61882a919591"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=False)
-        batch_op.create_foreign_key(
-            None, "room", ["room_id"], ["id"], ondelete="CASCADE"
-        )
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.drop_constraint("meeting_room_id_fkey", type_="foreignkey")
-        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=True)
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/74b2b0236931_add_transcript_source_kind.py
+++ b/server/migrations/versions/74b2b0236931_add_transcript_source_kind.py
@@ -20,14 +20,11 @@ depends_on: Union[str, Sequence[str], None] = None

 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    sourcekind_enum = sa.Enum("room", "live", "file", name="sourcekind")
-    sourcekind_enum.create(op.get_bind())
-
    op.add_column(
        "transcript",
        sa.Column(
            "source_kind",
-            sourcekind_enum,
+            sa.Enum("ROOM", "LIVE", "FILE", name="sourcekind"),
            nullable=True,
        ),
    )
@@ -46,8 +43,6 @@ def upgrade() -> None:
 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    op.drop_column("transcript", "source_kind")
-    sourcekind_enum = sa.Enum(name="sourcekind")
-    sourcekind_enum.drop(op.get_bind())


 # ### end Alembic commands ###
--- a/server/migrations/versions/764ce6db4388_add_zulip_message_id.py
+++ b/server/migrations/versions/764ce6db4388_add_zulip_message_id.py
@@ -5,28 +5,26 @@ Revises: 62dea3db63a5
 Create Date: 2024-09-06 14:02:06.649665

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
-revision: str = "764ce6db4388"
-down_revision: Union[str, None] = "62dea3db63a5"
+revision: str = '764ce6db4388'
+down_revision: Union[str, None] = '62dea3db63a5'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None


 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column(
-        "transcript", sa.Column("zulip_message_id", sa.Integer(), nullable=True)
-    )
+    op.add_column('transcript', sa.Column('zulip_message_id', sa.Integer(), nullable=True))
    # ### end Alembic commands ###


 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column("transcript", "zulip_message_id")
+    op.drop_column('transcript', 'zulip_message_id')
    # ### end Alembic commands ###
--- a/server/migrations/versions/8120ebc75366_populate_webvtt_from_topics.py
+++ b/server/migrations/versions/8120ebc75366_populate_webvtt_from_topics.py
@@ -1,106 +0,0 @@
-"""populate_webvtt_from_topics
-
-Revision ID: 8120ebc75366
-Revises: 116b2f287eab
-Create Date: 2025-08-11 19:11:01.316947
-
-"""
-
-import json
-from typing import Sequence, Union
-
-from alembic import op
-from sqlalchemy import text
-
-# revision identifiers, used by Alembic.
-revision: str = "8120ebc75366"
-down_revision: Union[str, None] = "116b2f287eab"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def topics_to_webvtt(topics):
-    """Convert topics list to WebVTT format string."""
-    if not topics:
-        return None
-
-    lines = ["WEBVTT", ""]
-
-    for topic in topics:
-        start_time = format_timestamp(topic.get("start"))
-        end_time = format_timestamp(topic.get("end"))
-        text = topic.get("text", "").strip()
-
-        if start_time and end_time and text:
-            lines.append(f"{start_time} --> {end_time}")
-            lines.append(text)
-            lines.append("")
-
-    return "\n".join(lines).strip()
-
-
-def format_timestamp(seconds):
-    """Format seconds to WebVTT timestamp format (HH:MM:SS.mmm)."""
-    if seconds is None:
-        return None
-
-    hours = int(seconds // 3600)
-    minutes = int((seconds % 3600) // 60)
-    secs = seconds % 60
-
-    return f"{hours:02d}:{minutes:02d}:{secs:06.3f}"
-
-
-def upgrade() -> None:
-    """Populate WebVTT field for all transcripts with topics."""
-
-    # Get connection
-    connection = op.get_bind()
-
-    # Query all transcripts with topics
-    result = connection.execute(
-        text("SELECT id, topics FROM transcript WHERE topics IS NOT NULL")
-    )
-
-    rows = result.fetchall()
-    print(f"Found {len(rows)} transcripts with topics")
-
-    updated_count = 0
-    error_count = 0
-
-    for row in rows:
-        transcript_id = row[0]
-        topics_data = row[1]
-
-        if not topics_data:
-            continue
-
-        try:
-            # Parse JSON if it's a string
-            if isinstance(topics_data, str):
-                topics_data = json.loads(topics_data)
-
-            # Convert topics to WebVTT format
-            webvtt_content = topics_to_webvtt(topics_data)
-
-            if webvtt_content:
-                # Update the webvtt field
-                connection.execute(
-                    text("UPDATE transcript SET webvtt = :webvtt WHERE id = :id"),
-                    {"webvtt": webvtt_content, "id": transcript_id},
-                )
-                updated_count += 1
-                print(f"✓ Updated transcript {transcript_id}")
-
-        except Exception as e:
-            error_count += 1
-            print(f"✗ Error updating transcript {transcript_id}: {e}")
-
-    print(f"\nMigration complete!")
-    print(f"  Updated: {updated_count}")
-    print(f"  Errors: {error_count}")
-
-
-def downgrade() -> None:
-    """Clear WebVTT field for all transcripts."""
-    op.execute(text("UPDATE transcript SET webvtt = NULL"))
--- a/server/migrations/versions/88d292678ba2_fix_transcript_json_nan_values.py
+++ b/server/migrations/versions/88d292678ba2_fix_transcript_json_nan_values.py
@@ -9,6 +9,8 @@ Create Date: 2025-07-15 19:30:19.876332
 from typing import Sequence, Union

 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "88d292678ba2"
@@ -19,7 +21,7 @@ depends_on: Union[str, Sequence[str], None] = None

 def upgrade() -> None:
    import json
-
+    import re
    from sqlalchemy import text

    # Get database connection
@@ -56,9 +58,7 @@ def upgrade() -> None:
            fixed_events = json.dumps(jevents)
            assert "NaN" not in fixed_events
        except (json.JSONDecodeError, AssertionError) as e:
-            print(
-                f"Warning: Invalid JSON for transcript {transcript_id}, skipping: {e}"
-            )
+            print(f"Warning: Invalid JSON for transcript {transcript_id}, skipping: {e}")
            continue

        # Update the record with fixed JSON
--- a/server/migrations/versions/9920ecfe2735_rename_transcript_to_text.py
+++ b/server/migrations/versions/9920ecfe2735_rename_transcript_to_text.py
@@ -5,13 +5,13 @@ Revises: 99365b0cd87b
 Create Date: 2023-11-02 18:55:17.019498

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import table, column
 from sqlalchemy import select
-from sqlalchemy.sql import column, table
+

 # revision identifiers, used by Alembic.
 revision: str = "9920ecfe2735"
--- a/server/migrations/versions/99365b0cd87b_add_title_short_and_long_summary_and_.py
+++ b/server/migrations/versions/99365b0cd87b_add_title_short_and_long_summary_and_.py
@@ -8,8 +8,8 @@ Create Date: 2023-09-01 20:19:47.216334

 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa

 # revision identifiers, used by Alembic.
 revision: str = "99365b0cd87b"
@@ -22,7 +22,7 @@ def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    op.execute(
        "UPDATE transcript SET events = "
-        'REPLACE(events::text, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\')::json;'
+        'REPLACE(events, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\');'
    )
    op.alter_column("transcript", "summary", new_column_name="long_summary")
    op.add_column("transcript", sa.Column("title", sa.String(), nullable=True))
@@ -34,7 +34,7 @@ def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    op.execute(
        "UPDATE transcript SET events = "
-        'REPLACE(events::text, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\')::json;'
+        'REPLACE(events, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\');'
    )
    with op.batch_alter_table("transcript", schema=None) as batch_op:
        batch_op.alter_column("long_summary", nullable=True, new_column_name="summary")
--- a/server/migrations/versions/9f5c78d352d6_datetime_timezone.py
+++ b/server/migrations/versions/9f5c78d352d6_datetime_timezone.py
@@ -1,121 +0,0 @@
-"""datetime timezone
-
-Revision ID: 9f5c78d352d6
-Revises: 8120ebc75366
-Create Date: 2025-08-13 19:18:27.113593
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = "9f5c78d352d6"
-down_revision: Union[str, None] = "8120ebc75366"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.alter_column(
-            "start_date",
-            existing_type=postgresql.TIMESTAMP(),
-            type_=sa.DateTime(timezone=True),
-            existing_nullable=True,
-        )
-        batch_op.alter_column(
-            "end_date",
-            existing_type=postgresql.TIMESTAMP(),
-            type_=sa.DateTime(timezone=True),
-            existing_nullable=True,
-        )
-
-    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
-        batch_op.alter_column(
-            "consent_timestamp",
-            existing_type=postgresql.TIMESTAMP(),
-            type_=sa.DateTime(timezone=True),
-            existing_nullable=False,
-        )
-
-    with op.batch_alter_table("recording", schema=None) as batch_op:
-        batch_op.alter_column(
-            "recorded_at",
-            existing_type=postgresql.TIMESTAMP(),
-            type_=sa.DateTime(timezone=True),
-            existing_nullable=False,
-        )
-
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.alter_column(
-            "created_at",
-            existing_type=postgresql.TIMESTAMP(),
-            type_=sa.DateTime(timezone=True),
-            existing_nullable=False,
-        )
-
-    with op.batch_alter_table("transcript", schema=None) as batch_op:
-        batch_op.alter_column(
-            "created_at",
-            existing_type=postgresql.TIMESTAMP(),
-            type_=sa.DateTime(timezone=True),
-            existing_nullable=True,
-        )
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("transcript", schema=None) as batch_op:
-        batch_op.alter_column(
-            "created_at",
-            existing_type=sa.DateTime(timezone=True),
-            type_=postgresql.TIMESTAMP(),
-            existing_nullable=True,
-        )
-
-    with op.batch_alter_table("room", schema=None) as batch_op:
-        batch_op.alter_column(
-            "created_at",
-            existing_type=sa.DateTime(timezone=True),
-            type_=postgresql.TIMESTAMP(),
-            existing_nullable=False,
-        )
-
-    with op.batch_alter_table("recording", schema=None) as batch_op:
-        batch_op.alter_column(
-            "recorded_at",
-            existing_type=sa.DateTime(timezone=True),
-            type_=postgresql.TIMESTAMP(),
-            existing_nullable=False,
-        )
-
-    with op.batch_alter_table("meeting_consent", schema=None) as batch_op:
-        batch_op.alter_column(
-            "consent_timestamp",
-            existing_type=sa.DateTime(timezone=True),
-            type_=postgresql.TIMESTAMP(),
-            existing_nullable=False,
-        )
-
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.alter_column(
-            "end_date",
-            existing_type=sa.DateTime(timezone=True),
-            type_=postgresql.TIMESTAMP(),
-            existing_nullable=True,
-        )
-        batch_op.alter_column(
-            "start_date",
-            existing_type=sa.DateTime(timezone=True),
-            type_=postgresql.TIMESTAMP(),
-            existing_nullable=True,
-        )
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/a7122bc0b2ca_add_shared_rooms.py
+++ b/server/migrations/versions/a7122bc0b2ca_add_shared_rooms.py
@@ -25,7 +25,7 @@ def upgrade() -> None:
        sa.Column(
            "is_shared",
            sa.Boolean(),
-            server_default=sa.text("false"),
+            server_default=sa.text("0"),
            nullable=False,
        ),
    )
--- a/server/migrations/versions/a9c9c229ee36_transcript_composite_index.py
+++ b/server/migrations/versions/a9c9c229ee36_transcript_composite_index.py
@@ -9,6 +9,8 @@ Create Date: 2025-07-15 20:09:40.253018
 from typing import Sequence, Union

 from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql

 # revision identifiers, used by Alembic.
 revision: str = "a9c9c229ee36"
--- a/server/migrations/versions/b0e5f7876032_add_meeting_is_active.py
+++ b/server/migrations/versions/b0e5f7876032_add_meeting_is_active.py
@@ -5,37 +5,30 @@ Revises: 6ea59639f30e
 Create Date: 2025-01-28 10:06:50.446233

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
-revision: str = "b0e5f7876032"
-down_revision: Union[str, None] = "6ea59639f30e"
+revision: str = 'b0e5f7876032'
+down_revision: Union[str, None] = '6ea59639f30e'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None


 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.add_column(
-            sa.Column(
-                "is_active",
-                sa.Boolean(),
-                server_default=sa.text("true"),
-                nullable=False,
-            )
-        )
+    with op.batch_alter_table('meeting', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('is_active', sa.Boolean(), server_default=sa.text('1'), nullable=False))

    # ### end Alembic commands ###


 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.drop_column("is_active")
+    with op.batch_alter_table('meeting', schema=None) as batch_op:
+        batch_op.drop_column('is_active')

    # ### end Alembic commands ###
--- a/server/migrations/versions/b1c33bd09963_add_search_optimization_indexes.py
+++ b/server/migrations/versions/b1c33bd09963_add_search_optimization_indexes.py
@@ -1,41 +0,0 @@
-"""add_search_optimization_indexes
-
-Revision ID: b1c33bd09963
-Revises: 9f5c78d352d6
-Create Date: 2025-08-14 17:26:02.117408
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "b1c33bd09963"
-down_revision: Union[str, None] = "9f5c78d352d6"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # Add indexes for actual search filtering patterns used in frontend
-    # Based on /browse page filters: room_id and source_kind
-
-    # Index for room_id + created_at (for room-specific searches with date ordering)
-    op.create_index(
-        "idx_transcript_room_id_created_at",
-        "transcript",
-        ["room_id", "created_at"],
-        if_not_exists=True,
-    )
-
-    # Index for source_kind alone (actively used filter in frontend)
-    op.create_index(
-        "idx_transcript_source_kind", "transcript", ["source_kind"], if_not_exists=True
-    )
-
-
-def downgrade() -> None:
-    # Remove the indexes in reverse order
-    op.drop_index("idx_transcript_source_kind", "transcript", if_exists=True)
-    op.drop_index("idx_transcript_room_id_created_at", "transcript", if_exists=True)
--- a/server/migrations/versions/b3df9681cae9_add_transcript_table.py
+++ b/server/migrations/versions/b3df9681cae9_add_transcript_table.py
@@ -8,8 +8,9 @@ Create Date: 2025-06-27 08:57:16.306940

 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "b3df9681cae9"
--- a/server/migrations/versions/b469348df210_remove_viewer_room_url.py
+++ b/server/migrations/versions/b469348df210_remove_viewer_room_url.py
@@ -8,8 +8,9 @@ Create Date: 2024-10-11 13:45:28.914902

 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "b469348df210"
--- a/server/migrations/versions/b7df9609542c_add_unique_constraint_one_active_.py
+++ b/server/migrations/versions/b7df9609542c_add_unique_constraint_one_active_.py
@@ -5,15 +5,15 @@ Revises: d7fbb74b673b
 Create Date: 2025-07-25 16:27:06.959868

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
-revision: str = "b7df9609542c"
-down_revision: Union[str, None] = "d7fbb74b673b"
+revision: str = 'b7df9609542c'
+down_revision: Union[str, None] = 'd7fbb74b673b'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None

@@ -22,14 +22,14 @@ def upgrade() -> None:
    # Create a partial unique index that ensures only one active meeting per room
    # This works for both PostgreSQL and SQLite
    op.create_index(
-        "idx_one_active_meeting_per_room",
-        "meeting",
-        ["room_id"],
+        'idx_one_active_meeting_per_room',
+        'meeting',
+        ['room_id'],
        unique=True,
-        postgresql_where=sa.text("is_active = true"),
-        sqlite_where=sa.text("is_active = 1"),
+        postgresql_where=sa.text('is_active = true'),
+        sqlite_where=sa.text('is_active = 1')
    )


 def downgrade() -> None:
-    op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
+    op.drop_index('idx_one_active_meeting_per_room', table_name='meeting')
--- a/server/migrations/versions/b9348748bbbc_reviewed.py
+++ b/server/migrations/versions/b9348748bbbc_reviewed.py
@@ -5,31 +5,25 @@ Revises: 125031f7cb78
 Create Date: 2023-12-13 15:37:51.303970

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa

 # revision identifiers, used by Alembic.
-revision: str = "b9348748bbbc"
-down_revision: Union[str, None] = "125031f7cb78"
+revision: str = 'b9348748bbbc'
+down_revision: Union[str, None] = '125031f7cb78'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None


 def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column(
-        "transcript",
-        sa.Column(
-            "reviewed", sa.Boolean(), server_default=sa.text("false"), nullable=False
-        ),
-    )
+    op.add_column('transcript', sa.Column('reviewed', sa.Boolean(), server_default=sa.text('0'), nullable=False))
    # ### end Alembic commands ###


 def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column("transcript", "reviewed")
+    op.drop_column('transcript', 'reviewed')
    # ### end Alembic commands ###
--- a/server/migrations/versions/ccd68dc784ff_add_performance_indexes.py
+++ b/server/migrations/versions/ccd68dc784ff_add_performance_indexes.py
@@ -9,6 +9,8 @@ Create Date: 2025-07-15 11:48:42.854741
 from typing import Sequence, Union

 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "ccd68dc784ff"
--- a/server/migrations/versions/d3ff3a39297f_add_recordings.py
+++ b/server/migrations/versions/d3ff3a39297f_add_recordings.py
@@ -8,8 +8,9 @@ Create Date: 2025-06-27 09:27:25.302152

 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "d3ff3a39297f"
--- a/server/migrations/versions/d7fbb74b673b_add_room_id_to_transcript.py
+++ b/server/migrations/versions/d7fbb74b673b_add_room_id_to_transcript.py
@@ -56,4 +56,4 @@ def downgrade() -> None:
    op.drop_index("idx_transcript_room_id", "transcript")

    # Drop the room_id column
-    op.drop_column("transcript", "room_id")
+    op.drop_column("transcript", "room_id")
--- a/server/migrations/versions/def1b5867d4c_make_meeting_room_id_nullable_but_keep_.py
+++ b/server/migrations/versions/def1b5867d4c_make_meeting_room_id_nullable_but_keep_.py
@@ -1,34 +0,0 @@
-"""make meeting room_id nullable but keep foreign key
-
-Revision ID: def1b5867d4c
-Revises: 0ce521cda2ee
-Create Date: 2025-09-11 09:42:18.697264
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "def1b5867d4c"
-down_revision: Union[str, None] = "0ce521cda2ee"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=True)
-
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    with op.batch_alter_table("meeting", schema=None) as batch_op:
-        batch_op.alter_column("room_id", existing_type=sa.VARCHAR(), nullable=False)
-
-    # ### end Alembic commands ###
--- a/server/migrations/versions/f819277e5169_audio_location.py
+++ b/server/migrations/versions/f819277e5169_audio_location.py
@@ -5,11 +5,11 @@ Revises: 4814901632bc
 Create Date: 2023-11-16 10:29:09.351664

 """
-
 from typing import Sequence, Union

-import sqlalchemy as sa
 from alembic import op
+import sqlalchemy as sa
+

 # revision identifiers, used by Alembic.
 revision: str = "f819277e5169"
--- a/server/pyproject.toml
+++ b/server/pyproject.toml
@@ -27,18 +27,17 @@ dependencies = [
    "prometheus-fastapi-instrumentator>=6.1.0",
    "sentencepiece>=0.1.99",
    "protobuf>=4.24.3",
+    "profanityfilter>=2.0.6",
    "celery>=5.3.4",
    "redis>=5.0.1",
    "python-jose[cryptography]>=3.3.0",
    "python-multipart>=0.0.6",
+    "faster-whisper>=0.10.0",
    "transformers>=4.36.2",
+    "black==24.1.1",
    "jsonschema>=4.23.0",
    "openai>=1.59.7",
    "psycopg2-binary>=2.9.10",
-    "llama-index>=0.12.52",
-    "llama-index-llms-openai-like>=0.4.0",
-    "pytest-env>=1.1.5",
-    "webvtt-py>=0.5.0",
 ]

 [dependency-groups]
@@ -55,9 +54,6 @@ tests = [
    "httpx-ws>=0.4.1",
    "pytest-httpx>=0.23.1",
    "pytest-celery>=0.0.0",
-    "pytest-recording>=0.13.4",
-    "pytest-docker>=3.2.3",
-    "asgi-lifespan>=2.1.0",
 ]
 aws = ["aioboto3>=11.2.0"]
 evaluation = [
@@ -66,15 +62,6 @@ evaluation = [
    "tqdm>=4.66.0",
    "pydantic>=2.1.1",
 ]
-local = [
-    "pyannote-audio>=3.3.2",
-    "faster-whisper>=0.10.0",
-]
-silero-vad = [
-    "silero-vad>=5.1.2",
-    "torch>=2.8.0",
-    "torchaudio>=2.8.0",
-]

 [tool.uv]
 default-groups = [
@@ -82,21 +69,6 @@ default-groups = [
    "tests",
    "aws",
    "evaluation",
-    "local",
-    "silero-vad"
-]
-
-[[tool.uv.index]]
-name = "pytorch-cpu"
-url = "https://download.pytorch.org/whl/cpu"
-explicit = true
-
-[tool.uv.sources]
-torch = [
-  { index = "pytorch-cpu" },
-]
-torchaudio = [
-  { index = "pytorch-cpu" },
 ]

 [build-system]
@@ -109,28 +81,10 @@ packages = ["reflector"]
 [tool.coverage.run]
 source = ["reflector"]

-[tool.pytest_env]
-ENVIRONMENT = "pytest"
-DATABASE_URL = "postgresql://test_user:test_password@localhost:15432/reflector_test"
-
 [tool.pytest.ini_options]
 addopts = "-ra -q --disable-pytest-warnings --cov --cov-report html -v"
 testpaths = ["tests"]
 asyncio_mode = "auto"
-markers = [
-    "gpu_modal: mark test to run only with GPU Modal endpoints (deselect with '-m \"not gpu_modal\"')",
-]
-
-[tool.ruff.lint]
-select = [
-    "I",       # isort - import sorting
-    "F401",    # unused imports
-    "PLC0415", # import-outside-top-level - detect inline imports
-]

 [tool.ruff.lint.per-file-ignores]
 "reflector/processors/summary/summary_builder.py" = ["E501"]
-"gpu/**.py" = ["PLC0415"]
-"reflector/tools/**.py" = ["PLC0415"]
-"migrations/versions/**.py" = ["PLC0415"]
-"tests/**.py" = ["PLC0415"]
--- a/server/reflector/app.py
+++ b/server/reflector/app.py
@@ -1,13 +1,12 @@
 from contextlib import asynccontextmanager

+import reflector.auth  # noqa
+import reflector.db  # noqa
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRoute
 from fastapi_pagination import add_pagination
 from prometheus_fastapi_instrumentator import Instrumentator
-
-import reflector.auth  # noqa
-import reflector.db  # noqa
 from reflector.events import subscribers_shutdown, subscribers_startup
 from reflector.logger import logger
 from reflector.metrics import metrics_init
--- a/server/reflector/asynctask.py
+++ b/server/reflector/asynctask.py
@@ -1,27 +0,0 @@
-import asyncio
-import functools
-
-from reflector.db import get_database
-
-
-def asynctask(f):
-    @functools.wraps(f)
-    def wrapper(*args, **kwargs):
-        async def run_with_db():
-            database = get_database()
-            await database.connect()
-            try:
-                return await f(*args, **kwargs)
-            finally:
-                await database.disconnect()
-
-        coro = run_with_db()
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = None
-        if loop and loop.is_running():
-            return loop.run_until_complete(coro)
-        return asyncio.run(coro)
-
-    return wrapper
--- a/server/reflector/auth/init.py
+++ b/server/reflector/auth/init.py
@@ -1,7 +1,6 @@
-import importlib
-
-from reflector.logger import logger
 from reflector.settings import settings
+from reflector.logger import logger
+import importlib

 logger.info(f"User authentication using {settings.AUTH_BACKEND}")
 module_name = f"reflector.auth.auth_{settings.AUTH_BACKEND}"
--- a/server/reflector/auth/auth_jwt.py
+++ b/server/reflector/auth/auth_jwt.py
@@ -4,7 +4,6 @@ from fastapi import Depends, HTTPException
 from fastapi.security import OAuth2PasswordBearer
 from jose import JWTError, jwt
 from pydantic import BaseModel
-
 from reflector.logger import logger
 from reflector.settings import settings

--- a/server/reflector/auth/auth_none.py
+++ b/server/reflector/auth/auth_none.py
@@ -1,8 +1,7 @@
+from pydantic import BaseModel
 from typing import Annotated
-
 from fastapi import Depends
 from fastapi.security import OAuth2PasswordBearer
-from pydantic import BaseModel

 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)

--- a/server/reflector/client.py
+++ b/server/reflector/client.py
@@ -1,12 +1,12 @@
 import argparse
 import asyncio
 import signal
-from typing import NoReturn

 from aiortc.contrib.signaling import add_signaling_arguments, create_signaling

 from reflector.logger import logger
 from reflector.stream_client import StreamClient
+from typing import NoReturn


 async def main() -> NoReturn:
@@ -51,7 +51,7 @@ async def main() -> NoReturn:

        logger.info(f"Cancelling {len(tasks)} outstanding tasks")
        await asyncio.gather(*tasks, return_exceptions=True)
-        logger.info(f"{'Flushing metrics'}")
+        logger.info(f'{"Flushing metrics"}')
        loop.stop()

    signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
--- a/server/reflector/db/init.py
+++ b/server/reflector/db/init.py
@@ -1,28 +1,11 @@
-import contextvars
-from typing import Optional
-
 import databases
 import sqlalchemy
-
 from reflector.events import subscribers_shutdown, subscribers_startup
 from reflector.settings import settings

+database = databases.Database(settings.DATABASE_URL)
 metadata = sqlalchemy.MetaData()

-_database_context: contextvars.ContextVar[Optional[databases.Database]] = (
-    contextvars.ContextVar("database", default=None)
-)
-
-
-def get_database() -> databases.Database:
-    """Get database instance for current asyncio context"""
-    db = _database_context.get()
-    if db is None:
-        db = databases.Database(settings.DATABASE_URL)
-        _database_context.set(db)
-    return db
-
-
 # import models
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
@@ -30,18 +13,16 @@ import reflector.db.rooms  # noqa
 import reflector.db.transcripts  # noqa

 kwargs = {}
-if "postgres" not in settings.DATABASE_URL:
-    raise Exception("Only postgres database is supported in reflector")
+if "sqlite" in settings.DATABASE_URL:
+    kwargs["connect_args"] = {"check_same_thread": False}
 engine = sqlalchemy.create_engine(settings.DATABASE_URL, **kwargs)


@subscribers_startup.append
 async def database_connect(_):
-    database = get_database()
    await database.connect()


@subscribers_shutdown.append
 async def database_disconnect(_):
-    database = get_database()
    await database.disconnect()
--- a/server/reflector/db/meetings.py
+++ b/server/reflector/db/meetings.py
@@ -2,9 +2,9 @@ from datetime import datetime
 from typing import Literal

 import sqlalchemy as sa
+from fastapi import HTTPException
 from pydantic import BaseModel, Field
-
-from reflector.db import get_database, metadata
+from reflector.db import database, metadata
 from reflector.db.rooms import Room
 from reflector.utils import generate_uuid4

@@ -15,14 +15,10 @@ meetings = sa.Table(
    sa.Column("room_name", sa.String),
    sa.Column("room_url", sa.String),
    sa.Column("host_room_url", sa.String),
-    sa.Column("start_date", sa.DateTime(timezone=True)),
-    sa.Column("end_date", sa.DateTime(timezone=True)),
-    sa.Column(
-        "room_id",
-        sa.String,
-        sa.ForeignKey("room.id", ondelete="CASCADE"),
-        nullable=True,
-    ),
+    sa.Column("start_date", sa.DateTime),
+    sa.Column("end_date", sa.DateTime),
+    sa.Column("user_id", sa.String),
+    sa.Column("room_id", sa.String),
    sa.Column("is_locked", sa.Boolean, nullable=False, server_default=sa.false()),
    sa.Column("room_mode", sa.String, nullable=False, server_default="normal"),
    sa.Column("recording_type", sa.String, nullable=False, server_default="cloud"),
@@ -45,27 +41,16 @@ meetings = sa.Table(
        server_default=sa.true(),
    ),
    sa.Index("idx_meeting_room_id", "room_id"),
-    sa.Index(
-        "idx_one_active_meeting_per_room",
-        "room_id",
-        unique=True,
-        postgresql_where=sa.text("is_active = true"),
-    ),
 )

 meeting_consent = sa.Table(
    "meeting_consent",
    metadata,
    sa.Column("id", sa.String, primary_key=True),
-    sa.Column(
-        "meeting_id",
-        sa.String,
-        sa.ForeignKey("meeting.id", ondelete="CASCADE"),
-        nullable=False,
-    ),
+    sa.Column("meeting_id", sa.String, sa.ForeignKey("meeting.id"), nullable=False),
    sa.Column("user_id", sa.String),
    sa.Column("consent_given", sa.Boolean, nullable=False),
-    sa.Column("consent_timestamp", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("consent_timestamp", sa.DateTime, nullable=False),
 )


@@ -84,7 +69,8 @@ class Meeting(BaseModel):
    host_room_url: str
    start_date: datetime
    end_date: datetime
-    room_id: str | None
+    user_id: str | None = None
+    room_id: str | None = None
    is_locked: bool = False
    room_mode: Literal["normal", "group"] = "normal"
    recording_type: Literal["none", "local", "cloud"] = "cloud"
@@ -103,8 +89,12 @@ class MeetingController:
        host_room_url: str,
        start_date: datetime,
        end_date: datetime,
+        user_id: str,
        room: Room,
    ):
+        """
+        Create a new meeting
+        """
        meeting = Meeting(
            id=id,
            room_name=room_name,
@@ -112,6 +102,7 @@ class MeetingController:
            host_room_url=host_room_url,
            start_date=start_date,
            end_date=end_date,
+            user_id=user_id,
            room_id=room.id,
            is_locked=room.is_locked,
            room_mode=room.room_mode,
@@ -119,25 +110,34 @@ class MeetingController:
            recording_trigger=room.recording_trigger,
        )
        query = meetings.insert().values(**meeting.model_dump())
-        await get_database().execute(query)
+        await database.execute(query)
        return meeting

    async def get_all_active(self) -> list[Meeting]:
+        """
+        Get active meetings.
+        """
        query = meetings.select().where(meetings.c.is_active)
-        return await get_database().fetch_all(query)
+        return await database.fetch_all(query)

    async def get_by_room_name(
        self,
        room_name: str,
-    ) -> Meeting | None:
+    ) -> Meeting:
+        """
+        Get a meeting by room name.
+        """
        query = meetings.select().where(meetings.c.room_name == room_name)
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None

        return Meeting(**result)

-    async def get_active(self, room: Room, current_time: datetime) -> Meeting | None:
+    async def get_active(self, room: Room, current_time: datetime) -> Meeting:
+        """
+        Get latest active meeting for a room.
+        """
        end_date = getattr(meetings.c, "end_date")
        query = (
            meetings.select()
@@ -150,22 +150,42 @@ class MeetingController:
            )
            .order_by(end_date.desc())
        )
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None

        return Meeting(**result)

    async def get_by_id(self, meeting_id: str, **kwargs) -> Meeting | None:
+        """
+        Get a meeting by id
+        """
        query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None
        return Meeting(**result)

+    async def get_by_id_for_http(self, meeting_id: str, user_id: str | None) -> Meeting:
+        """
+        Get a meeting by ID for HTTP request.
+
+        If not found, it will raise a 404 error.
+        """
+        query = meetings.select().where(meetings.c.id == meeting_id)
+        result = await database.fetch_one(query)
+        if not result:
+            raise HTTPException(status_code=404, detail="Meeting not found")
+
+        meeting = Meeting(**result)
+        if result["user_id"] != user_id:
+            meeting.host_room_url = ""
+
+        return meeting
+
    async def update_meeting(self, meeting_id: str, **kwargs):
        query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
-        await get_database().execute(query)
+        await database.execute(query)


 class MeetingConsentController:
@@ -173,7 +193,7 @@ class MeetingConsentController:
        query = meeting_consent.select().where(
            meeting_consent.c.meeting_id == meeting_id
        )
-        results = await get_database().fetch_all(query)
+        results = await database.fetch_all(query)
        return [MeetingConsent(**result) for result in results]

    async def get_by_meeting_and_user(
@@ -184,10 +204,10 @@ class MeetingConsentController:
            meeting_consent.c.meeting_id == meeting_id,
            meeting_consent.c.user_id == user_id,
        )
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if result is None:
            return None
-        return MeetingConsent(**result)
+        return MeetingConsent(**result) if result else None

    async def upsert(self, consent: MeetingConsent) -> MeetingConsent:
        """Create new consent or update existing one for authenticated users"""
@@ -206,14 +226,14 @@ class MeetingConsentController:
                        consent_timestamp=consent.consent_timestamp,
                    )
                )
-                await get_database().execute(query)
+                await database.execute(query)

                existing.consent_given = consent.consent_given
                existing.consent_timestamp = consent.consent_timestamp
                return existing

        query = meeting_consent.insert().values(**consent.model_dump())
-        await get_database().execute(query)
+        await database.execute(query)
        return consent

    async def has_any_denial(self, meeting_id: str) -> bool:
@@ -222,7 +242,7 @@ class MeetingConsentController:
            meeting_consent.c.meeting_id == meeting_id,
            meeting_consent.c.consent_given.is_(False),
        )
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        return result is not None


--- a/server/reflector/db/recordings.py
+++ b/server/reflector/db/recordings.py
@@ -3,8 +3,7 @@ from typing import Literal

 import sqlalchemy as sa
 from pydantic import BaseModel, Field
-
-from reflector.db import get_database, metadata
+from reflector.db import database, metadata
 from reflector.utils import generate_uuid4

 recordings = sa.Table(
@@ -13,7 +12,7 @@ recordings = sa.Table(
    sa.Column("id", sa.String, primary_key=True),
    sa.Column("bucket_name", sa.String, nullable=False),
    sa.Column("object_key", sa.String, nullable=False),
-    sa.Column("recorded_at", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("recorded_at", sa.DateTime, nullable=False),
    sa.Column(
        "status",
        sa.String,
@@ -37,12 +36,12 @@ class Recording(BaseModel):
 class RecordingController:
    async def create(self, recording: Recording):
        query = recordings.insert().values(**recording.model_dump())
-        await get_database().execute(query)
+        await database.execute(query)
        return recording

    async def get_by_id(self, id: str) -> Recording:
        query = recordings.select().where(recordings.c.id == id)
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        return Recording(**result) if result else None

    async def get_by_object_key(self, bucket_name: str, object_key: str) -> Recording:
@@ -50,12 +49,8 @@ class RecordingController:
            recordings.c.bucket_name == bucket_name,
            recordings.c.object_key == object_key,
        )
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        return Recording(**result) if result else None

-    async def remove_by_id(self, id: str) -> None:
-        query = recordings.delete().where(recordings.c.id == id)
-        await get_database().execute(query)
-

 recordings_controller = RecordingController()
--- a/server/reflector/db/rooms.py
+++ b/server/reflector/db/rooms.py
@@ -1,15 +1,13 @@
-import secrets
-from datetime import datetime, timezone
+from datetime import datetime
 from sqlite3 import IntegrityError
 from typing import Literal

 import sqlalchemy
 from fastapi import HTTPException
 from pydantic import BaseModel, Field
-from sqlalchemy.sql import false, or_
-
-from reflector.db import get_database, metadata
+from reflector.db import database, metadata
 from reflector.utils import generate_uuid4
+from sqlalchemy.sql import false, or_

 rooms = sqlalchemy.Table(
    "room",
@@ -17,7 +15,7 @@ rooms = sqlalchemy.Table(
    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
    sqlalchemy.Column("name", sqlalchemy.String, nullable=False, unique=True),
    sqlalchemy.Column("user_id", sqlalchemy.String, nullable=False),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime, nullable=False),
    sqlalchemy.Column(
        "zulip_auto_post", sqlalchemy.Boolean, nullable=False, server_default=false()
    ),
@@ -41,8 +39,7 @@ rooms = sqlalchemy.Table(
    sqlalchemy.Column(
        "is_shared", sqlalchemy.Boolean, nullable=False, server_default=false()
    ),
-    sqlalchemy.Column("webhook_url", sqlalchemy.String, nullable=True),
-    sqlalchemy.Column("webhook_secret", sqlalchemy.String, nullable=True),
+    sqlalchemy.Column("background_information", sqlalchemy.Text),
    sqlalchemy.Index("idx_room_is_shared", "is_shared"),
 )

@@ -51,7 +48,7 @@ class Room(BaseModel):
    id: str = Field(default_factory=generate_uuid4)
    name: str
    user_id: str
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    created_at: datetime = Field(default_factory=datetime.utcnow)
    zulip_auto_post: bool = False
    zulip_stream: str = ""
    zulip_topic: str = ""
@@ -62,8 +59,7 @@ class Room(BaseModel):
        "none", "prompt", "automatic", "automatic-2nd-participant"
    ] = "automatic-2nd-participant"
    is_shared: bool = False
-    webhook_url: str | None = None
-    webhook_secret: str | None = None
+    background_information: str = ""


 class RoomController:
@@ -97,7 +93,7 @@ class RoomController:
        if return_query:
            return query

-        results = await get_database().fetch_all(query)
+        results = await database.fetch_all(query)
        return results

    async def add(
@@ -112,15 +108,11 @@ class RoomController:
        recording_type: str,
        recording_trigger: str,
        is_shared: bool,
-        webhook_url: str = "",
-        webhook_secret: str = "",
+        background_information: str = "",
    ):
        """
        Add a new room
        """
-        if webhook_url and not webhook_secret:
-            webhook_secret = secrets.token_urlsafe(32)
-
        room = Room(
            name=name,
            user_id=user_id,
@@ -132,12 +124,11 @@ class RoomController:
            recording_type=recording_type,
            recording_trigger=recording_trigger,
            is_shared=is_shared,
-            webhook_url=webhook_url,
-            webhook_secret=webhook_secret,
+            background_information=background_information,
        )
        query = rooms.insert().values(**room.model_dump())
        try:
-            await get_database().execute(query)
+            await database.execute(query)
        except IntegrityError:
            raise HTTPException(status_code=400, detail="Room name is not unique")
        return room
@@ -146,12 +137,9 @@ class RoomController:
        """
        Update a room fields with key/values in values
        """
-        if values.get("webhook_url") and not values.get("webhook_secret"):
-            values["webhook_secret"] = secrets.token_urlsafe(32)
-
        query = rooms.update().where(rooms.c.id == room.id).values(**values)
        try:
-            await get_database().execute(query)
+            await database.execute(query)
        except IntegrityError:
            raise HTTPException(status_code=400, detail="Room name is not unique")

@@ -166,7 +154,7 @@ class RoomController:
        query = rooms.select().where(rooms.c.id == room_id)
        if "user_id" in kwargs:
            query = query.where(rooms.c.user_id == kwargs["user_id"])
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None
        return Room(**result)
@@ -178,7 +166,7 @@ class RoomController:
        query = rooms.select().where(rooms.c.name == room_name)
        if "user_id" in kwargs:
            query = query.where(rooms.c.user_id == kwargs["user_id"])
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None
        return Room(**result)
@@ -190,7 +178,7 @@ class RoomController:
        If not found, it will raise a 404 error.
        """
        query = rooms.select().where(rooms.c.id == meeting_id)
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            raise HTTPException(status_code=404, detail="Room not found")

@@ -212,7 +200,7 @@ class RoomController:
        if user_id is not None and room.user_id != user_id:
            return
        query = rooms.delete().where(rooms.c.id == room_id)
-        await get_database().execute(query)
+        await database.execute(query)


 rooms_controller = RoomController()
--- a/server/reflector/db/search.py
+++ b/server/reflector/db/search.py
@@ -1,468 +0,0 @@
-"""Search functionality for transcripts and other entities."""
-
-import itertools
-from dataclasses import dataclass
-from datetime import datetime
-from io import StringIO
-from typing import Annotated, Any, Dict, Iterator
-
-import sqlalchemy
-import webvtt
-from databases.interfaces import Record as DbRecord
-from fastapi import HTTPException
-from pydantic import (
-    BaseModel,
-    Field,
-    NonNegativeFloat,
-    NonNegativeInt,
-    TypeAdapter,
-    ValidationError,
-    constr,
-    field_serializer,
-)
-
-from reflector.db import get_database
-from reflector.db.rooms import rooms
-from reflector.db.transcripts import SourceKind, TranscriptStatus, transcripts
-from reflector.db.utils import is_postgresql
-from reflector.logger import logger
-from reflector.utils.string import NonEmptyString, try_parse_non_empty_string
-
-DEFAULT_SEARCH_LIMIT = 20
-SNIPPET_CONTEXT_LENGTH = 50  # Characters before/after match to include
-DEFAULT_SNIPPET_MAX_LENGTH = NonNegativeInt(150)
-DEFAULT_MAX_SNIPPETS = NonNegativeInt(3)
-LONG_SUMMARY_MAX_SNIPPETS = 2
-
-SearchQueryBase = constr(min_length=1, strip_whitespace=True)
-SearchLimitBase = Annotated[int, Field(ge=1, le=100)]
-SearchOffsetBase = Annotated[int, Field(ge=0)]
-SearchTotalBase = Annotated[int, Field(ge=0)]
-
-SearchQuery = Annotated[SearchQueryBase, Field(description="Search query text")]
-search_query_adapter = TypeAdapter(SearchQuery)
-SearchLimit = Annotated[SearchLimitBase, Field(description="Results per page")]
-SearchOffset = Annotated[
-    SearchOffsetBase, Field(description="Number of results to skip")
-]
-SearchTotal = Annotated[
-    SearchTotalBase, Field(description="Total number of search results")
-]
-
-WEBVTT_SPEC_HEADER = "WEBVTT"
-
-WebVTTContent = Annotated[
-    str,
-    Field(min_length=len(WEBVTT_SPEC_HEADER), description="WebVTT content"),
-]
-
-
-class WebVTTProcessor:
-    """Stateless processor for WebVTT content operations."""
-
-    @staticmethod
-    def parse(raw_content: str) -> WebVTTContent:
-        """Parse WebVTT content and return it as a string."""
-        if not raw_content.startswith(WEBVTT_SPEC_HEADER):
-            raise ValueError(f"Invalid WebVTT content, no header {WEBVTT_SPEC_HEADER}")
-        return raw_content
-
-    @staticmethod
-    def extract_text(webvtt_content: WebVTTContent) -> str:
-        """Extract plain text from WebVTT content using webvtt library."""
-        try:
-            buffer = StringIO(webvtt_content)
-            vtt = webvtt.read_buffer(buffer)
-            return " ".join(caption.text for caption in vtt if caption.text)
-        except webvtt.errors.MalformedFileError as e:
-            logger.warning(f"Malformed WebVTT content: {e}")
-            return ""
-        except (UnicodeDecodeError, ValueError) as e:
-            logger.warning(f"Failed to decode WebVTT content: {e}")
-            return ""
-        except AttributeError as e:
-            logger.error(
-                f"WebVTT parsing error - unexpected format: {e}", exc_info=True
-            )
-            return ""
-        except Exception as e:
-            logger.error(f"Unexpected error parsing WebVTT: {e}", exc_info=True)
-            return ""
-
-    @staticmethod
-    def generate_snippets(
-        webvtt_content: WebVTTContent,
-        query: SearchQuery,
-        max_snippets: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
-    ) -> list[str]:
-        """Generate snippets from WebVTT content."""
-        return SnippetGenerator.generate(
-            WebVTTProcessor.extract_text(webvtt_content),
-            query,
-            max_snippets=max_snippets,
-        )
-
-
-@dataclass(frozen=True)
-class SnippetCandidate:
-    """Represents a candidate snippet with its position."""
-
-    _text: str
-    start: NonNegativeInt
-    _original_text_length: int
-
-    @property
-    def end(self) -> NonNegativeInt:
-        """Calculate end position from start and raw text length."""
-        return self.start + len(self._text)
-
-    def text(self) -> str:
-        """Get display text with ellipses added if needed."""
-        result = self._text.strip()
-        if self.start > 0:
-            result = "..." + result
-        if self.end < self._original_text_length:
-            result = result + "..."
-        return result
-
-
-class SearchParameters(BaseModel):
-    """Validated search parameters for full-text search."""
-
-    query_text: SearchQuery | None = None
-    limit: SearchLimit = DEFAULT_SEARCH_LIMIT
-    offset: SearchOffset = 0
-    user_id: str | None = None
-    room_id: str | None = None
-    source_kind: SourceKind | None = None
-
-
-class SearchResultDB(BaseModel):
-    """Intermediate model for validating raw database results."""
-
-    id: str = Field(..., min_length=1)
-    created_at: datetime
-    status: str = Field(..., min_length=1)
-    duration: float | None = Field(None, ge=0)
-    user_id: str | None = None
-    title: str | None = None
-    source_kind: SourceKind
-    room_id: str | None = None
-    rank: float = Field(..., ge=0, le=1)
-
-
-class SearchResult(BaseModel):
-    """Public search result model with computed fields."""
-
-    id: str = Field(..., min_length=1)
-    title: str | None = None
-    user_id: str | None = None
-    room_id: str | None = None
-    room_name: str | None = None
-    source_kind: SourceKind
-    created_at: datetime
-    status: TranscriptStatus = Field(..., min_length=1)
-    rank: float = Field(..., ge=0, le=1)
-    duration: NonNegativeFloat | None = Field(..., description="Duration in seconds")
-    search_snippets: list[str] = Field(
-        description="Text snippets around search matches"
-    )
-    total_match_count: NonNegativeInt = Field(
-        default=0, description="Total number of matches found in the transcript"
-    )
-
-    @field_serializer("created_at", when_used="json")
-    def serialize_datetime(self, dt: datetime) -> str:
-        if dt.tzinfo is None:
-            return dt.isoformat() + "Z"
-        return dt.isoformat()
-
-
-class SnippetGenerator:
-    """Stateless generator for text snippets and match operations."""
-
-    @staticmethod
-    def find_all_matches(text: str, query: str) -> Iterator[int]:
-        """Generate all match positions for a query in text."""
-        if not text:
-            logger.warning("Empty text for search query in find_all_matches")
-            return
-        if not query:
-            logger.warning("Empty query for search text in find_all_matches")
-            return
-
-        text_lower = text.lower()
-        query_lower = query.lower()
-        start = 0
-        prev_start = start
-        while (pos := text_lower.find(query_lower, start)) != -1:
-            yield pos
-            start = pos + len(query_lower)
-            if start <= prev_start:
-                raise ValueError("panic! find_all_matches is not incremental")
-            prev_start = start
-
-    @staticmethod
-    def count_matches(text: str, query: SearchQuery) -> NonNegativeInt:
-        """Count total number of matches for a query in text."""
-        ZERO = NonNegativeInt(0)
-        if not text:
-            logger.warning("Empty text for search query in count_matches")
-            return ZERO
-        assert query is not None
-        return NonNegativeInt(
-            sum(1 for _ in SnippetGenerator.find_all_matches(text, query))
-        )
-
-    @staticmethod
-    def create_snippet(
-        text: str, match_pos: int, max_length: int = DEFAULT_SNIPPET_MAX_LENGTH
-    ) -> SnippetCandidate:
-        """Create a snippet from a match position."""
-        snippet_start = NonNegativeInt(max(0, match_pos - SNIPPET_CONTEXT_LENGTH))
-        snippet_end = min(len(text), match_pos + max_length - SNIPPET_CONTEXT_LENGTH)
-
-        snippet_text = text[snippet_start:snippet_end]
-
-        return SnippetCandidate(
-            _text=snippet_text, start=snippet_start, _original_text_length=len(text)
-        )
-
-    @staticmethod
-    def filter_non_overlapping(
-        candidates: Iterator[SnippetCandidate],
-    ) -> Iterator[str]:
-        """Filter out overlapping snippets and return only display text."""
-        last_end = 0
-        for candidate in candidates:
-            display_text = candidate.text()
-            # it means that next overlapping snippets simply don't get included
-            # it's fine as simplistic logic and users probably won't care much because they already have their search results just fin
-            if candidate.start >= last_end and display_text:
-                yield display_text
-                last_end = candidate.end
-
-    @staticmethod
-    def generate(
-        text: str,
-        query: SearchQuery,
-        max_length: NonNegativeInt = DEFAULT_SNIPPET_MAX_LENGTH,
-        max_snippets: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
-    ) -> list[str]:
-        """Generate snippets from text."""
-        assert query is not None
-        if not text:
-            logger.warning("Empty text for generate_snippets")
-            return []
-
-        candidates = (
-            SnippetGenerator.create_snippet(text, pos, max_length)
-            for pos in SnippetGenerator.find_all_matches(text, query)
-        )
-        filtered = SnippetGenerator.filter_non_overlapping(candidates)
-        snippets = list(itertools.islice(filtered, max_snippets))
-
-        # Fallback to first word search if no full matches
-        # it's another assumption: proper snippet logic generation is quite complicated and tied to db logic, so simplification is used here
-        if not snippets and " " in query:
-            first_word = query.split()[0]
-            return SnippetGenerator.generate(text, first_word, max_length, max_snippets)
-
-        return snippets
-
-    @staticmethod
-    def from_summary(
-        summary: str,
-        query: SearchQuery,
-        max_snippets: NonNegativeInt = LONG_SUMMARY_MAX_SNIPPETS,
-    ) -> list[str]:
-        """Generate snippets from summary text."""
-        return SnippetGenerator.generate(summary, query, max_snippets=max_snippets)
-
-    @staticmethod
-    def combine_sources(
-        summary: NonEmptyString | None,
-        webvtt: WebVTTContent | None,
-        query: SearchQuery,
-        max_total: NonNegativeInt = DEFAULT_MAX_SNIPPETS,
-    ) -> tuple[list[str], NonNegativeInt]:
-        """Combine snippets from multiple sources and return total match count.
-
-        Returns (snippets, total_match_count) tuple.
-
-        snippets can be empty for real in case of e.g. title match
-        """
-
-        assert (
-            summary is not None or webvtt is not None
-        ), "At least one source must be present"
-
-        webvtt_matches = 0
-        summary_matches = 0
-
-        if webvtt:
-            webvtt_text = WebVTTProcessor.extract_text(webvtt)
-            webvtt_matches = SnippetGenerator.count_matches(webvtt_text, query)
-
-        if summary:
-            summary_matches = SnippetGenerator.count_matches(summary, query)
-
-        total_matches = NonNegativeInt(webvtt_matches + summary_matches)
-
-        summary_snippets = (
-            SnippetGenerator.from_summary(summary, query) if summary else []
-        )
-
-        if len(summary_snippets) >= max_total:
-            return summary_snippets[:max_total], total_matches
-
-        remaining = max_total - len(summary_snippets)
-        webvtt_snippets = (
-            WebVTTProcessor.generate_snippets(webvtt, query, remaining)
-            if webvtt
-            else []
-        )
-
-        return summary_snippets + webvtt_snippets, total_matches
-
-
-class SearchController:
-    """Controller for search operations across different entities."""
-
-    @classmethod
-    async def search_transcripts(
-        cls, params: SearchParameters
-    ) -> tuple[list[SearchResult], int]:
-        """
-        Full-text search for transcripts using PostgreSQL tsvector.
-        Returns (results, total_count).
-        """
-
-        if not is_postgresql():
-            logger.warning(
-                "Full-text search requires PostgreSQL. Returning empty results."
-            )
-            return [], 0
-
-        base_columns = [
-            transcripts.c.id,
-            transcripts.c.title,
-            transcripts.c.created_at,
-            transcripts.c.duration,
-            transcripts.c.status,
-            transcripts.c.user_id,
-            transcripts.c.room_id,
-            transcripts.c.source_kind,
-            transcripts.c.webvtt,
-            transcripts.c.long_summary,
-            sqlalchemy.case(
-                (
-                    transcripts.c.room_id.isnot(None) & rooms.c.id.is_(None),
-                    "Deleted Room",
-                ),
-                else_=rooms.c.name,
-            ).label("room_name"),
-        ]
-        search_query = None
-        if params.query_text is not None:
-            search_query = sqlalchemy.func.websearch_to_tsquery(
-                "english", params.query_text
-            )
-            rank_column = sqlalchemy.func.ts_rank(
-                transcripts.c.search_vector_en,
-                search_query,
-                32,  # normalization flag: rank/(rank+1) for 0-1 range
-            ).label("rank")
-        else:
-            rank_column = sqlalchemy.cast(1.0, sqlalchemy.Float).label("rank")
-
-        columns = base_columns + [rank_column]
-        base_query = sqlalchemy.select(columns).select_from(
-            transcripts.join(rooms, transcripts.c.room_id == rooms.c.id, isouter=True)
-        )
-
-        if params.query_text is not None:
-            # because already initialized based on params.query_text presence above
-            assert search_query is not None
-            base_query = base_query.where(
-                transcripts.c.search_vector_en.op("@@")(search_query)
-            )
-
-        if params.user_id:
-            base_query = base_query.where(
-                sqlalchemy.or_(
-                    transcripts.c.user_id == params.user_id, rooms.c.is_shared
-                )
-            )
-        else:
-            base_query = base_query.where(rooms.c.is_shared)
-        if params.room_id:
-            base_query = base_query.where(transcripts.c.room_id == params.room_id)
-        if params.source_kind:
-            base_query = base_query.where(
-                transcripts.c.source_kind == params.source_kind
-            )
-
-        if params.query_text is not None:
-            order_by = sqlalchemy.desc(sqlalchemy.text("rank"))
-        else:
-            order_by = sqlalchemy.desc(transcripts.c.created_at)
-
-        query = base_query.order_by(order_by).limit(params.limit).offset(params.offset)
-
-        rs = await get_database().fetch_all(query)
-
-        count_query = sqlalchemy.select([sqlalchemy.func.count()]).select_from(
-            base_query.alias("search_results")
-        )
-        total = await get_database().fetch_val(count_query)
-
-        def _process_result(r: DbRecord) -> SearchResult:
-            r_dict: Dict[str, Any] = dict(r)
-
-            webvtt_raw: str | None = r_dict.pop("webvtt", None)
-            webvtt: WebVTTContent | None
-            if webvtt_raw:
-                webvtt = WebVTTProcessor.parse(webvtt_raw)
-            else:
-                webvtt = None
-
-            long_summary_r: str | None = r_dict.pop("long_summary", None)
-            long_summary: NonEmptyString = try_parse_non_empty_string(long_summary_r)
-            room_name: str | None = r_dict.pop("room_name", None)
-            db_result = SearchResultDB.model_validate(r_dict)
-
-            at_least_one_source = webvtt is not None or long_summary is not None
-            has_query = params.query_text is not None
-            snippets, total_match_count = (
-                SnippetGenerator.combine_sources(
-                    long_summary, webvtt, params.query_text, DEFAULT_MAX_SNIPPETS
-                )
-                if has_query and at_least_one_source
-                else ([], 0)
-            )
-
-            return SearchResult(
-                **db_result.model_dump(),
-                room_name=room_name,
-                search_snippets=snippets,
-                total_match_count=total_match_count,
-            )
-
-        try:
-            results = [_process_result(r) for r in rs]
-        except ValidationError as e:
-            logger.error(f"Invalid search result data: {e}", exc_info=True)
-            raise HTTPException(
-                status_code=500, detail="Internal search result data consistency error"
-            )
-        except Exception as e:
-            logger.error(f"Error processing search results: {e}", exc_info=True)
-            raise
-
-        return results, total
-
-
-search_controller = SearchController()
-webvtt_processor = WebVTTProcessor()
-snippet_generator = SnippetGenerator()
--- a/server/reflector/db/transcripts.py
+++ b/server/reflector/db/transcripts.py
@@ -3,27 +3,20 @@ import json
 import os
 import shutil
 from contextlib import asynccontextmanager
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Literal

 import sqlalchemy
 from fastapi import HTTPException
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
-from sqlalchemy import Enum
-from sqlalchemy.dialects.postgresql import TSVECTOR
-from sqlalchemy.sql import false, or_
-
-from reflector.db import get_database, metadata
-from reflector.db.recordings import recordings_controller
-from reflector.db.rooms import rooms
-from reflector.db.utils import is_postgresql
-from reflector.logger import logger
+from reflector.db import database, metadata
 from reflector.processors.types import Word as ProcessorWord
 from reflector.settings import settings
-from reflector.storage import get_recordings_storage, get_transcripts_storage
+from reflector.storage import get_transcripts_storage
 from reflector.utils import generate_uuid4
-from reflector.utils.webvtt import topics_to_webvtt
+from sqlalchemy import Enum
+from sqlalchemy.sql import false, or_


 class SourceKind(enum.StrEnum):
@@ -40,7 +33,7 @@ transcripts = sqlalchemy.Table(
    sqlalchemy.Column("status", sqlalchemy.String),
    sqlalchemy.Column("locked", sqlalchemy.Boolean),
    sqlalchemy.Column("duration", sqlalchemy.Float),
-    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True)),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime),
    sqlalchemy.Column("title", sqlalchemy.String),
    sqlalchemy.Column("short_summary", sqlalchemy.String),
    sqlalchemy.Column("long_summary", sqlalchemy.String),
@@ -82,55 +75,19 @@ transcripts = sqlalchemy.Table(
    # same field could've been in recording/meeting, and it's maybe even ok to dupe it at need
    sqlalchemy.Column("audio_deleted", sqlalchemy.Boolean),
    sqlalchemy.Column("room_id", sqlalchemy.String),
-    sqlalchemy.Column("webvtt", sqlalchemy.Text),
    sqlalchemy.Index("idx_transcript_recording_id", "recording_id"),
    sqlalchemy.Index("idx_transcript_user_id", "user_id"),
    sqlalchemy.Index("idx_transcript_created_at", "created_at"),
    sqlalchemy.Index("idx_transcript_user_id_recording_id", "user_id", "recording_id"),
    sqlalchemy.Index("idx_transcript_room_id", "room_id"),
-    sqlalchemy.Index("idx_transcript_source_kind", "source_kind"),
-    sqlalchemy.Index("idx_transcript_room_id_created_at", "room_id", "created_at"),
 )

-# Add PostgreSQL-specific full-text search column
-# This matches the migration in migrations/versions/116b2f287eab_add_full_text_search.py
-if is_postgresql():
-    transcripts.append_column(
-        sqlalchemy.Column(
-            "search_vector_en",
-            TSVECTOR,
-            sqlalchemy.Computed(
-                "setweight(to_tsvector('english', coalesce(title, '')), 'A') || "
-                "setweight(to_tsvector('english', coalesce(long_summary, '')), 'B') || "
-                "setweight(to_tsvector('english', coalesce(webvtt, '')), 'C')",
-                persisted=True,
-            ),
-        )
-    )
-    # Add GIN index for the search vector
-    transcripts.append_constraint(
-        sqlalchemy.Index(
-            "idx_transcript_search_vector_en",
-            "search_vector_en",
-            postgresql_using="gin",
-        )
-    )
-

 def generate_transcript_name() -> str:
    now = datetime.now(timezone.utc)
    return f"Transcript {now.strftime('%Y-%m-%d %H:%M:%S')}"


-TranscriptStatus = Literal[
-    "idle", "uploaded", "recording", "processing", "error", "ended"
-]
-
-
-class StrValue(BaseModel):
-    value: str
-
-
 class AudioWaveform(BaseModel):
    data: list[float]

@@ -189,18 +146,14 @@ class TranscriptParticipant(BaseModel):


 class Transcript(BaseModel):
-    """Full transcript model with all fields."""
-
    id: str = Field(default_factory=generate_uuid4)
    user_id: str | None = None
    name: str = Field(default_factory=generate_transcript_name)
-    status: TranscriptStatus = "idle"
+    status: str = "idle"
+    locked: bool = False
    duration: float = 0
    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
    title: str | None = None
-    source_kind: SourceKind
-    room_id: str | None = None
-    locked: bool = False
    short_summary: str | None = None
    long_summary: str | None = None
    topics: list[TranscriptTopic] = []
@@ -214,8 +167,9 @@ class Transcript(BaseModel):
    meeting_id: str | None = None
    recording_id: str | None = None
    zulip_message_id: int | None = None
+    source_kind: SourceKind
    audio_deleted: bool | None = None
-    webvtt: str | None = None
+    room_id: str | None = None

    @field_serializer("created_at", when_used="json")
    def serialize_datetime(self, dt: datetime) -> str:
@@ -316,12 +270,10 @@ class Transcript(BaseModel):
        # we need to create an url to be used for diarization
        # we can't use the audio_mp3_filename because it's not accessible
        # from the diarization processor
+        from datetime import timedelta

-        # TODO don't import app in db
-        from reflector.app import app  # noqa: PLC0415
-
-        # TODO a util + don''t import views in db
-        from reflector.views.transcripts import create_access_token  # noqa: PLC0415
+        from reflector.app import app
+        from reflector.views.transcripts import create_access_token

        path = app.url_path_for(
            "transcript_get_audio_mp3",
@@ -382,6 +334,7 @@ class TranscriptController:
        - `room_id`: filter transcripts by room ID
        - `search_term`: filter transcripts by search term
        """
+        from reflector.db.rooms import rooms

        query = transcripts.select().join(
            rooms, transcripts.c.room_id == rooms.c.id, isouter=True
@@ -432,7 +385,7 @@ class TranscriptController:
        if return_query:
            return query

-        results = await get_database().fetch_all(query)
+        results = await database.fetch_all(query)
        return results

    async def get_by_id(self, transcript_id: str, **kwargs) -> Transcript | None:
@@ -442,7 +395,7 @@ class TranscriptController:
        query = transcripts.select().where(transcripts.c.id == transcript_id)
        if "user_id" in kwargs:
            query = query.where(transcripts.c.user_id == kwargs["user_id"])
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None
        return Transcript(**result)
@@ -456,7 +409,7 @@ class TranscriptController:
        query = transcripts.select().where(transcripts.c.recording_id == recording_id)
        if "user_id" in kwargs:
            query = query.where(transcripts.c.user_id == kwargs["user_id"])
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            return None
        return Transcript(**result)
@@ -474,7 +427,7 @@ class TranscriptController:
            if order_by.startswith("-"):
                field = field.desc()
            query = query.order_by(field)
-        results = await get_database().fetch_all(query)
+        results = await database.fetch_all(query)
        return [Transcript(**result) for result in results]

    async def get_by_id_for_http(
@@ -492,7 +445,7 @@ class TranscriptController:
        to determine if the user can access the transcript.
        """
        query = transcripts.select().where(transcripts.c.id == transcript_id)
-        result = await get_database().fetch_one(query)
+        result = await database.fetch_one(query)
        if not result:
            raise HTTPException(status_code=404, detail="Transcript not found")

@@ -545,52 +498,23 @@ class TranscriptController:
            room_id=room_id,
        )
        query = transcripts.insert().values(**transcript.model_dump())
-        await get_database().execute(query)
+        await database.execute(query)
        return transcript

-    # TODO investigate why mutate= is used. it's used in one place currently, maybe because of ORM field updates.
-    # using mutate=True is discouraged
-    async def update(
-        self, transcript: Transcript, values: dict, mutate=False
-    ) -> Transcript:
+    async def update(self, transcript: Transcript, values: dict, mutate=True):
        """
-        Update a transcript fields with key/values in values.
-        Returns a copy of the transcript with updated values.
+        Update a transcript fields with key/values in values
        """
-        values = TranscriptController._handle_topics_update(values)
-
        query = (
            transcripts.update()
            .where(transcripts.c.id == transcript.id)
            .values(**values)
        )
-        await get_database().execute(query)
+        await database.execute(query)
        if mutate:
            for key, value in values.items():
                setattr(transcript, key, value)

-        updated_transcript = transcript.model_copy(update=values)
-        return updated_transcript
-
-    @staticmethod
-    def _handle_topics_update(values: dict) -> dict:
-        """Auto-update WebVTT when topics are updated."""
-
-        if values.get("webvtt") is not None:
-            logger.warn("trying to update read-only webvtt column")
-            pass
-
-        topics_data = values.get("topics")
-        if topics_data is None:
-            return values
-
-        return {
-            **values,
-            "webvtt": topics_to_webvtt(
-                [TranscriptTopic(**topic_dict) for topic_dict in topics_data]
-            ),
-        }
-
    async def remove_by_id(
        self,
        transcript_id: str,
@@ -604,55 +528,23 @@ class TranscriptController:
            return
        if user_id is not None and transcript.user_id != user_id:
            return
-        if transcript.audio_location == "storage" and not transcript.audio_deleted:
-            try:
-                await get_transcripts_storage().delete_file(
-                    transcript.storage_audio_path
-                )
-            except Exception as e:
-                logger.warning(
-                    "Failed to delete transcript audio from storage",
-                    exc_info=e,
-                    transcript_id=transcript.id,
-                )
        transcript.unlink()
-        if transcript.recording_id:
-            try:
-                recording = await recordings_controller.get_by_id(
-                    transcript.recording_id
-                )
-                if recording:
-                    try:
-                        await get_recordings_storage().delete_file(recording.object_key)
-                    except Exception as e:
-                        logger.warning(
-                            "Failed to delete recording object from S3",
-                            exc_info=e,
-                            recording_id=transcript.recording_id,
-                        )
-                    await recordings_controller.remove_by_id(transcript.recording_id)
-            except Exception as e:
-                logger.warning(
-                    "Failed to delete recording row",
-                    exc_info=e,
-                    recording_id=transcript.recording_id,
-                )
        query = transcripts.delete().where(transcripts.c.id == transcript_id)
-        await get_database().execute(query)
+        await database.execute(query)

    async def remove_by_recording_id(self, recording_id: str):
        """
        Remove a transcript by recording_id
        """
        query = transcripts.delete().where(transcripts.c.recording_id == recording_id)
-        await get_database().execute(query)
+        await database.execute(query)

    @asynccontextmanager
    async def transaction(self):
        """
        A context manager for database transaction
        """
-        async with get_database().transaction(isolation="serializable"):
+        async with database.transaction(isolation="serializable"):
            yield

    async def append_event(
@@ -665,7 +557,11 @@ class TranscriptController:
        Append an event to a transcript
        """
        resp = transcript.add_event(event=event, data=data)
-        await self.update(transcript, {"events": transcript.events_dump()})
+        await self.update(
+            transcript,
+            {"events": transcript.events_dump()},
+            mutate=False,
+        )
        return resp

    async def upsert_topic(
@@ -677,7 +573,11 @@ class TranscriptController:
        Upsert topics to a transcript
        """
        transcript.upsert_topic(topic)
-        await self.update(transcript, {"topics": transcript.topics_dump()})
+        await self.update(
+            transcript,
+            {"topics": transcript.topics_dump()},
+            mutate=False,
+        )

    async def move_mp3_to_storage(self, transcript: Transcript):
        """
@@ -702,8 +602,7 @@ class TranscriptController:
            )

            # indicate on the transcript that the audio is now on storage
-            # mutates transcript argument
-            await self.update(transcript, {"audio_location": "storage"}, mutate=True)
+            await self.update(transcript, {"audio_location": "storage"})

        # unlink the local file
        transcript.audio_mp3_filename.unlink(missing_ok=True)
@@ -727,7 +626,11 @@ class TranscriptController:
        Add/update a participant to a transcript
        """
        result = transcript.upsert_participant(participant)
-        await self.update(transcript, {"participants": transcript.participants_dump()})
+        await self.update(
+            transcript,
+            {"participants": transcript.participants_dump()},
+            mutate=False,
+        )
        return result

    async def delete_participant(
@@ -739,29 +642,11 @@ class TranscriptController:
        Delete a participant from a transcript
        """
        transcript.delete_participant(participant_id)
-        await self.update(transcript, {"participants": transcript.participants_dump()})
-
-    async def set_status(
-        self, transcript_id: str, status: TranscriptStatus
-    ) -> TranscriptEvent | None:
-        """
-        Update the status of a transcript
-
-        Will add an event STATUS + update the status field of transcript
-        """
-        async with self.transaction():
-            transcript = await self.get_by_id(transcript_id)
-            if not transcript:
-                raise Exception(f"Transcript {transcript_id} not found")
-            if transcript.status == status:
-                return
-            resp = await self.append_event(
-                transcript=transcript,
-                event="STATUS",
-                data=StrValue(value=status),
-            )
-            await self.update(transcript, {"status": status})
-        return resp
+        await self.update(
+            transcript,
+            {"participants": transcript.participants_dump()},
+            mutate=False,
+        )


 transcripts_controller = TranscriptController()
--- a/server/reflector/db/utils.py
+++ b/server/reflector/db/utils.py
@@ -1,9 +0,0 @@
-"""Database utility functions."""
-
-from reflector.db import get_database
-
-
-def is_postgresql() -> bool:
-    return get_database().url.scheme and get_database().url.scheme.startswith(
-        "postgresql"
-    )
--- a/server/reflector/llm.py
+++ b/server/reflector/llm.py
@@ -1,83 +0,0 @@
-from typing import Type, TypeVar
-
-from llama_index.core import Settings
-from llama_index.core.output_parsers import PydanticOutputParser
-from llama_index.core.program import LLMTextCompletionProgram
-from llama_index.core.response_synthesizers import TreeSummarize
-from llama_index.llms.openai_like import OpenAILike
-from pydantic import BaseModel
-
-T = TypeVar("T", bound=BaseModel)
-
-STRUCTURED_RESPONSE_PROMPT_TEMPLATE = """
-Based on the following analysis, provide the information in the requested JSON format:
-
-Analysis:
-{analysis}
-
-{format_instructions}
-"""
-
-
-class LLM:
-    def __init__(self, settings, temperature: float = 0.4, max_tokens: int = 2048):
-        self.settings_obj = settings
-        self.model_name = settings.LLM_MODEL
-        self.url = settings.LLM_URL
-        self.api_key = settings.LLM_API_KEY
-        self.context_window = settings.LLM_CONTEXT_WINDOW
-        self.temperature = temperature
-        self.max_tokens = max_tokens
-
-        # Configure llamaindex Settings
-        self._configure_llamaindex()
-
-    def _configure_llamaindex(self):
-        """Configure llamaindex Settings with OpenAILike LLM"""
-        Settings.llm = OpenAILike(
-            model=self.model_name,
-            api_base=self.url,
-            api_key=self.api_key,
-            context_window=self.context_window,
-            is_chat_model=True,
-            is_function_calling_model=False,
-            temperature=self.temperature,
-            max_tokens=self.max_tokens,
-        )
-
-    async def get_response(
-        self, prompt: str, texts: list[str], tone_name: str | None = None
-    ) -> str:
-        """Get a text response using TreeSummarize for non-function-calling models"""
-        summarizer = TreeSummarize(verbose=False)
-        response = await summarizer.aget_response(prompt, texts, tone_name=tone_name)
-        return str(response).strip()
-
-    async def get_structured_response(
-        self,
-        prompt: str,
-        texts: list[str],
-        output_cls: Type[T],
-        tone_name: str | None = None,
-    ) -> T:
-        """Get structured output from LLM for non-function-calling models"""
-        summarizer = TreeSummarize(verbose=True)
-        response = await summarizer.aget_response(prompt, texts, tone_name=tone_name)
-
-        output_parser = PydanticOutputParser(output_cls)
-
-        program = LLMTextCompletionProgram.from_defaults(
-            output_parser=output_parser,
-            prompt_template_str=STRUCTURED_RESPONSE_PROMPT_TEMPLATE,
-            verbose=False,
-        )
-
-        format_instructions = output_parser.format(
-            "Please structure the above information in the following JSON format:"
-        )
-
-        output = await program.acall(
-            analysis=str(response), format_instructions=format_instructions
-        )
-
-        return output
--- a/server/reflector/llm/init.py
+++ b/server/reflector/llm/init.py
@@ -0,0 +1,2 @@
+from .base import LLM  # noqa: F401
+from .llm_params import LLMTaskParams  # noqa: F401
--- a/server/reflector/llm/base.py
+++ b/server/reflector/llm/base.py
@@ -0,0 +1,338 @@
+import importlib
+import json
+import re
+from typing import TypeVar
+
+import nltk
+from prometheus_client import Counter, Histogram
+from reflector.llm.llm_params import TaskParams
+from reflector.logger import logger as reflector_logger
+from reflector.settings import settings
+from reflector.utils.retry import retry
+from transformers import GenerationConfig
+
+T = TypeVar("T", bound="LLM")
+
+
+class LLM:
+    _nltk_downloaded = False
+    _registry = {}
+    m_generate = Histogram(
+        "llm_generate",
+        "Time spent in LLM.generate",
+        ["backend"],
+    )
+    m_generate_call = Counter(
+        "llm_generate_call",
+        "Number of calls to LLM.generate",
+        ["backend"],
+    )
+    m_generate_success = Counter(
+        "llm_generate_success",
+        "Number of successful calls to LLM.generate",
+        ["backend"],
+    )
+    m_generate_failure = Counter(
+        "llm_generate_failure",
+        "Number of failed calls to LLM.generate",
+        ["backend"],
+    )
+
+    @classmethod
+    def ensure_nltk(cls):
+        """
+        Make sure NLTK package is installed. Searches in the cache and
+        downloads only if needed.
+        """
+        if not cls._nltk_downloaded:
+            nltk.download("punkt_tab")
+            # For POS tagging
+            nltk.download("averaged_perceptron_tagger_eng")
+            cls._nltk_downloaded = True
+
+    @classmethod
+    def register(cls, name, klass):
+        cls._registry[name] = klass
+
+    @classmethod
+    def get_instance(cls, model_name: str | None = None, name: str = None) -> T:
+        """
+        Return an instance depending on the settings.
+        Settings used:
+
+        - `LLM_BACKEND`: key of the backend, defaults to `oobabooga`
+        - `LLM_URL`: url of the backend
+        """
+        if name is None:
+            name = settings.LLM_BACKEND
+        if name not in cls._registry:
+            module_name = f"reflector.llm.llm_{name}"
+            importlib.import_module(module_name)
+        cls.ensure_nltk()
+        return cls._registry[name](model_name)
+
+    def get_model_name(self) -> str:
+        """
+        Get the currently set model name
+        """
+        return self._get_model_name()
+
+    def _get_model_name(self) -> str:
+        pass
+
+    def set_model_name(self, model_name: str) -> bool:
+        """
+        Update the model name with the provided model name
+        """
+        return self._set_model_name(model_name)
+
+    def _set_model_name(self, model_name: str) -> bool:
+        raise NotImplementedError
+
+    @property
+    def template(self) -> str:
+        """
+        Return the LLM Prompt template
+        """
+        return """
+        ### Human:
+        {instruct}
+
+        {text}
+
+        ### Assistant:
+        """
+
+    def __init__(self):
+        name = self.__class__.__name__
+        self.m_generate = self.m_generate.labels(name)
+        self.m_generate_call = self.m_generate_call.labels(name)
+        self.m_generate_success = self.m_generate_success.labels(name)
+        self.m_generate_failure = self.m_generate_failure.labels(name)
+        self.detokenizer = nltk.tokenize.treebank.TreebankWordDetokenizer()
+
+    @property
+    def tokenizer(self):
+        """
+        Return the tokenizer instance used by LLM
+        """
+        return self._get_tokenizer()
+
+    def _get_tokenizer(self):
+        pass
+
+    async def generate(
+        self,
+        prompt: str,
+        logger: reflector_logger,
+        gen_schema: dict | None = None,
+        gen_cfg: GenerationConfig | None = None,
+        **kwargs,
+    ) -> dict:
+        logger.info("LLM generate", prompt=repr(prompt))
+
+        if gen_cfg:
+            gen_cfg = gen_cfg.to_dict()
+        self.m_generate_call.inc()
+        try:
+            with self.m_generate.time():
+                result = await retry(self._generate)(
+                    prompt=prompt,
+                    gen_schema=gen_schema,
+                    gen_cfg=gen_cfg,
+                    **kwargs,
+                )
+            self.m_generate_success.inc()
+
+        except Exception:
+            logger.exception("Failed to call llm after retrying")
+            self.m_generate_failure.inc()
+            raise
+
+        logger.debug("LLM result [raw]", result=repr(result))
+        if isinstance(result, str):
+            result = self._parse_json(result)
+        logger.debug("LLM result [parsed]", result=repr(result))
+
+        return result
+
+    async def completion(
+        self, messages: list, logger: reflector_logger, **kwargs
+    ) -> dict:
+        """
+        Use /v1/chat/completion Open-AI compatible endpoint from the URL
+        It's up to the user to validate anything or transform the result
+        """
+        logger.info("LLM completions", messages=messages)
+
+        try:
+            with self.m_generate.time():
+                result = await retry(self._completion)(messages=messages, **kwargs)
+            self.m_generate_success.inc()
+        except Exception:
+            logger.exception("Failed to call llm after retrying")
+            self.m_generate_failure.inc()
+            raise
+
+        logger.debug("LLM completion result", result=repr(result))
+        return result
+
+    def ensure_casing(self, title: str) -> str:
+        """
+        LLM takes care of word casing, but in rare cases this
+        can falter. This is a fallback to ensure the casing of
+        topics is in a proper format.
+
+        We select nouns, verbs and adjectives and check if camel
+         casing is present and fix it, if not. Will not perform
+         any other changes.
+        """
+        tokens = nltk.word_tokenize(title)
+        pos_tags = nltk.pos_tag(tokens)
+        camel_cased = []
+
+        whitelisted_pos_tags = [
+            "NN",
+            "NNS",
+            "NNP",
+            "NNPS",  # Noun POS
+            "VB",
+            "VBD",
+            "VBG",
+            "VBN",
+            "VBP",
+            "VBZ",  # Verb POS
+            "JJ",
+            "JJR",
+            "JJS",  # Adjective POS
+        ]
+
+        # If at all there is an exception, do not block other reflector
+        # processes. Return the LLM generated title, at the least.
+        try:
+            for word, pos in pos_tags:
+                if pos in whitelisted_pos_tags and word[0].islower():
+                    camel_cased.append(word[0].upper() + word[1:])
+                else:
+                    camel_cased.append(word)
+            modified_title = self.detokenizer.detokenize(camel_cased)
+
+            # Irrespective of casing changes, the starting letter
+            # of title is always upper-cased
+            title = modified_title[0].upper() + modified_title[1:]
+        except Exception as e:
+            reflector_logger.info(
+                f"Failed to ensure casing on {title=} with exception : {str(e)}"
+            )
+
+        return title
+
+    def trim_title(self, title: str) -> str:
+        """
+        List of manual trimming to the title.
+
+        Longer titles are prone to run into A prefix of phrases that don't
+        really add any descriptive information and in some cases, this
+        behaviour can be repeated for several consecutive topics. Trim the
+        titles to maintain quality of titles.
+        """
+        phrases_to_remove = ["Discussing", "Discussion on", "Discussion about"]
+        try:
+            pattern = (
+                r"\b(?:"
+                + "|".join(re.escape(phrase) for phrase in phrases_to_remove)
+                + r")\b"
+            )
+            title = re.sub(pattern, "", title, flags=re.IGNORECASE)
+        except Exception as e:
+            reflector_logger.info(f"Failed to trim {title=} with exception : {str(e)}")
+        return title
+
+    async def _generate(
+        self, prompt: str, gen_schema: dict | None, gen_cfg: dict | None, **kwargs
+    ) -> str:
+        raise NotImplementedError
+
+    async def _completion(
+        self, messages: list, logger: reflector_logger, **kwargs
+    ) -> dict:
+        raise NotImplementedError
+
+    def _parse_json(self, result: str) -> dict:
+        result = result.strip()
+        # try detecting code block if exist
+        # starts with ```json\n, ends with ```
+        # or starts with ```\n, ends with ```
+        # or starts with \n```javascript\n, ends with ```
+
+        regex = r"```(json|javascript|)?(.*)```"
+        matches = re.findall(regex, result.strip(), re.MULTILINE | re.DOTALL)
+        if matches:
+            result = matches[0][1]
+
+        else:
+            # maybe the prompt has been started with ```json
+            # so if text ends with ```, just remove it and use it as json
+            if result.endswith("```"):
+                result = result[:-3]
+
+        return json.loads(result.strip())
+
+    def text_token_threshold(self, task_params: TaskParams | None) -> int:
+        """
+        Choose the token size to set as the threshold to pack the LLM calls
+        """
+        buffer_token_size = 100
+        default_output_tokens = 1000
+        context_window = self.tokenizer.model_max_length
+        tokens = self.tokenizer.tokenize(
+            self.create_prompt(instruct=task_params.instruct, text="")
+        )
+        threshold = context_window - len(tokens) - buffer_token_size
+        if task_params.gen_cfg:
+            threshold -= task_params.gen_cfg.max_new_tokens
+        else:
+            threshold -= default_output_tokens
+        return threshold
+
+    def split_corpus(
+        self,
+        corpus: str,
+        task_params: TaskParams,
+        token_threshold: int | None = None,
+    ) -> list[str]:
+        """
+        Split the input to the LLM due to CUDA memory limitations and LLM context window
+        restrictions.
+
+        Accumulate tokens from full sentences till threshold and yield accumulated
+        tokens. Reset accumulation when threshold is reached and repeat process.
+        """
+        if not token_threshold:
+            token_threshold = self.text_token_threshold(task_params=task_params)
+
+        accumulated_tokens = []
+        accumulated_sentences = []
+        accumulated_token_count = 0
+        corpus_sentences = nltk.sent_tokenize(corpus)
+
+        for sentence in corpus_sentences:
+            tokens = self.tokenizer.tokenize(sentence)
+            if accumulated_token_count + len(tokens) <= token_threshold:
+                accumulated_token_count += len(tokens)
+                accumulated_tokens.extend(tokens)
+                accumulated_sentences.append(sentence)
+            else:
+                yield "".join(accumulated_sentences)
+                accumulated_token_count = len(tokens)
+                accumulated_tokens = tokens
+                accumulated_sentences = [sentence]
+
+        if accumulated_tokens:
+            yield " ".join(accumulated_sentences)
+
+    def create_prompt(self, instruct: str, text: str) -> str:
+        """
+        Create a consumable prompt based on the prompt template
+        """
+        return self.template.format(instruct=instruct, text=text)
--- a/server/reflector/llm/llm_modal.py
+++ b/server/reflector/llm/llm_modal.py
@@ -0,0 +1,151 @@
+import httpx
+from reflector.llm.base import LLM
+from reflector.logger import logger as reflector_logger
+from reflector.settings import settings
+from reflector.utils.retry import retry
+from transformers import AutoTokenizer, GenerationConfig
+
+
+class ModalLLM(LLM):
+    def __init__(self, model_name: str | None = None):
+        super().__init__()
+        self.timeout = settings.LLM_TIMEOUT
+        self.llm_url = settings.LLM_URL + "/llm"
+        self.headers = {
+            "Authorization": f"Bearer {settings.LLM_MODAL_API_KEY}",
+        }
+        self._set_model_name(model_name if model_name else settings.DEFAULT_LLM)
+
+    @property
+    def supported_models(self):
+        """
+        List of currently supported models on this GPU platform
+        """
+        # TODO: Query the specific GPU platform
+        # Replace this with a HTTP call
+        return [
+            "lmsys/vicuna-13b-v1.5",
+            "HuggingFaceH4/zephyr-7b-alpha",
+            "NousResearch/Hermes-3-Llama-3.1-8B",
+        ]
+
+    async def _generate(
+        self, prompt: str, gen_schema: dict | None, gen_cfg: dict | None, **kwargs
+    ):
+        json_payload = {"prompt": prompt}
+        if gen_schema:
+            json_payload["gen_schema"] = gen_schema
+        if gen_cfg:
+            json_payload["gen_cfg"] = gen_cfg
+
+        # Handing over generation of the final summary to Zephyr model
+        # but replacing the Vicuna model will happen after more testing
+        # TODO: Create a mapping of model names and cloud deployments
+        if self.model_name == "HuggingFaceH4/zephyr-7b-alpha":
+            self.llm_url = settings.ZEPHYR_LLM_URL + "/llm"
+
+        async with httpx.AsyncClient() as client:
+            response = await retry(client.post)(
+                self.llm_url,
+                headers=self.headers,
+                json=json_payload,
+                timeout=self.timeout,
+                retry_timeout=60 * 5,
+                follow_redirects=True,
+            )
+            response.raise_for_status()
+            text = response.json()["text"]
+            return text
+
+    async def _completion(self, messages: list, **kwargs) -> dict:
+        kwargs.setdefault("temperature", 0.3)
+        kwargs.setdefault("max_tokens", 2048)
+        kwargs.setdefault("stream", False)
+        kwargs.setdefault("repetition_penalty", 1)
+        kwargs.setdefault("top_p", 1)
+        kwargs.setdefault("top_k", -1)
+        kwargs.setdefault("min_p", 0.05)
+        data = {"messages": messages, "model": self.model_name, **kwargs}
+
+        if self.model_name == "NousResearch/Hermes-3-Llama-3.1-8B":
+            self.llm_url = settings.HERMES_3_8B_LLM_URL + "/v1/chat/completions"
+
+        async with httpx.AsyncClient() as client:
+            response = await retry(client.post)(
+                self.llm_url,
+                headers=self.headers,
+                json=data,
+                timeout=self.timeout,
+                retry_timeout=60 * 5,
+                follow_redirects=True,
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def _set_model_name(self, model_name: str) -> bool:
+        """
+        Set the model name
+        """
+        # Abort, if the model is not supported
+        if model_name not in self.supported_models:
+            reflector_logger.info(
+                f"Attempted to change {model_name=}, but is not supported."
+                f"Setting model and tokenizer failed !"
+            )
+            return False
+        # Abort, if the model is already set
+        elif hasattr(self, "model_name") and model_name == self._get_model_name():
+            reflector_logger.info("No change in model. Setting model skipped.")
+            return False
+        # Update model name and tokenizer
+        self.model_name = model_name
+        self.llm_tokenizer = AutoTokenizer.from_pretrained(
+            self.model_name, cache_dir=settings.CACHE_DIR
+        )
+        reflector_logger.info(f"Model set to {model_name=}. Tokenizer updated.")
+        return True
+
+    def _get_tokenizer(self) -> AutoTokenizer:
+        """
+        Return the currently used LLM tokenizer
+        """
+        return self.llm_tokenizer
+
+    def _get_model_name(self) -> str:
+        """
+        Return the current model name from the instance details
+        """
+        return self.model_name
+
+
+LLM.register("modal", ModalLLM)
+
+if __name__ == "__main__":
+    from reflector.logger import logger
+
+    async def main():
+        llm = ModalLLM()
+        prompt = llm.create_prompt(
+            instruct="Complete the following task",
+            text="Tell me a joke about programming.",
+        )
+        result = await llm.generate(prompt=prompt, logger=logger)
+        print(result)
+
+        gen_schema = {
+            "type": "object",
+            "properties": {"response": {"type": "string"}},
+        }
+
+        result = await llm.generate(prompt=prompt, gen_schema=gen_schema, logger=logger)
+        print(result)
+
+        gen_cfg = GenerationConfig(max_new_tokens=150)
+        result = await llm.generate(
+            prompt=prompt, gen_cfg=gen_cfg, gen_schema=gen_schema, logger=logger
+        )
+        print(result)
+
+    import asyncio
+
+    asyncio.run(main())
--- a/server/reflector/llm/llm_oobabooga.py
+++ b/server/reflector/llm/llm_oobabooga.py
@@ -0,0 +1,29 @@
+import httpx
+
+from reflector.llm.base import LLM
+from reflector.settings import settings
+
+
+class OobaboogaLLM(LLM):
+    def __init__(self, model_name: str | None = None):
+        super().__init__()
+
+    async def _generate(
+        self, prompt: str, gen_schema: dict | None, gen_cfg: dict | None, **kwargs
+    ):
+        json_payload = {"prompt": prompt}
+        if gen_schema:
+            json_payload["gen_schema"] = gen_schema
+        if gen_cfg:
+            json_payload.update(gen_cfg)
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                settings.LLM_URL,
+                headers={"Content-Type": "application/json"},
+                json=json_payload,
+            )
+            response.raise_for_status()
+            return response.json()
+
+
+LLM.register("oobabooga", OobaboogaLLM)
--- a/server/reflector/llm/llm_openai.py
+++ b/server/reflector/llm/llm_openai.py
@@ -0,0 +1,48 @@
+import httpx
+from transformers import GenerationConfig
+
+from reflector.llm.base import LLM
+from reflector.logger import logger
+from reflector.settings import settings
+
+
+class OpenAILLM(LLM):
+    def __init__(self, model_name: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        self.openai_key = settings.LLM_OPENAI_KEY
+        self.openai_url = settings.LLM_URL
+        self.openai_model = settings.LLM_OPENAI_MODEL
+        self.openai_temperature = settings.LLM_OPENAI_TEMPERATURE
+        self.timeout = settings.LLM_TIMEOUT
+        self.max_tokens = settings.LLM_MAX_TOKENS
+        logger.info(f"LLM use openai backend at {self.openai_url}")
+
+    async def _generate(
+        self,
+        prompt: str,
+        gen_schema: dict | None,
+        gen_cfg: GenerationConfig | None,
+        **kwargs,
+    ) -> str:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.openai_key}",
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(
+                self.openai_url,
+                headers=headers,
+                json={
+                    "model": self.openai_model,
+                    "prompt": prompt,
+                    "max_tokens": self.max_tokens,
+                    "temperature": self.openai_temperature,
+                },
+            )
+            response.raise_for_status()
+            result = response.json()
+            return result["choices"][0]["text"]
+
+
+LLM.register("openai", OpenAILLM)
--- a/server/reflector/llm/llm_params.py
+++ b/server/reflector/llm/llm_params.py
@@ -0,0 +1,219 @@
+from typing import Optional, TypeVar
+
+from pydantic import BaseModel
+from transformers import GenerationConfig
+
+
+class TaskParams(BaseModel, arbitrary_types_allowed=True):
+    instruct: str
+    gen_cfg: Optional[GenerationConfig] = None
+    gen_schema: Optional[dict] = None
+
+
+T = TypeVar("T", bound="LLMTaskParams")
+
+
+class LLMTaskParams:
+    _registry = {}
+
+    @classmethod
+    def register(cls, task, klass) -> None:
+        cls._registry[task] = klass
+
+    @classmethod
+    def get_instance(cls, task: str) -> T:
+        return cls._registry[task]()
+
+    @property
+    def task_params(self) -> TaskParams | None:
+        """
+        Fetch the task related parameters
+        """
+        return self._get_task_params()
+
+    def _get_task_params(self) -> None:
+        pass
+
+
+class FinalLongSummaryParams(LLMTaskParams):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._gen_cfg = GenerationConfig(
+            max_new_tokens=1000, num_beams=3, do_sample=True, temperature=0.3
+        )
+        self._instruct = """
+        Take the key ideas and takeaways from the text and create a short
+         summary. Be sure to keep the length of the response to a minimum.
+         Do not include trivial information in the summary.
+          """
+        self._schema = {
+            "type": "object",
+            "properties": {"long_summary": {"type": "string"}},
+        }
+        self._task_params = TaskParams(
+            instruct=self._instruct, gen_schema=self._schema, gen_cfg=self._gen_cfg
+        )
+
+    def _get_task_params(self) -> TaskParams:
+        """gen_schema
+        Return the parameters associated with a specific LLM task
+        """
+        return self._task_params
+
+
+class FinalShortSummaryParams(LLMTaskParams):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._gen_cfg = GenerationConfig(
+            max_new_tokens=800, num_beams=3, do_sample=True, temperature=0.3
+        )
+        self._instruct = """
+        Take the key ideas and takeaways from the text and create a short
+         summary. Be sure to keep the length of the response to a minimum.
+         Do not include trivial information in the summary.
+          """
+        self._schema = {
+            "type": "object",
+            "properties": {"short_summary": {"type": "string"}},
+        }
+        self._task_params = TaskParams(
+            instruct=self._instruct, gen_schema=self._schema, gen_cfg=self._gen_cfg
+        )
+
+    def _get_task_params(self) -> TaskParams:
+        """
+        Return the parameters associated with a specific LLM task
+        """
+        return self._task_params
+
+
+class FinalTitleParams(LLMTaskParams):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._gen_cfg = GenerationConfig(
+            max_new_tokens=200, num_beams=5, do_sample=True, temperature=0.5
+        )
+        self._instruct = """
+            Combine the following individual titles into one single short title that
+            condenses the essence of all titles.
+        """
+        self._schema = {
+            "type": "object",
+            "properties": {"title": {"type": "string"}},
+        }
+        self._task_params = TaskParams(
+            instruct=self._instruct, gen_schema=self._schema, gen_cfg=self._gen_cfg
+        )
+
+    def _get_task_params(self) -> TaskParams:
+        """
+        Return the parameters associated with a specific LLM task
+        """
+        return self._task_params
+
+
+class TopicParams(LLMTaskParams):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._gen_cfg = GenerationConfig(
+            max_new_tokens=500, num_beams=6, do_sample=True, temperature=0.9
+        )
+        self._instruct = """
+                Create a JSON object as response.The JSON object must have 2 fields:
+                i) title and ii) summary.
+                For the title field, generate a very detailed and self-explanatory
+                 title for the given text. Let the title be as descriptive as possible.
+                For the summary field, summarize the given text in a maximum of
+                two sentences.
+            """
+        self._schema = {
+            "type": "object",
+            "properties": {
+                "title": {"type": "string"},
+                "summary": {"type": "string"},
+            },
+        }
+        self._task_params = TaskParams(
+            instruct=self._instruct, gen_schema=self._schema, gen_cfg=self._gen_cfg
+        )
+
+    def _get_task_params(self) -> TaskParams:
+        """
+        Return the parameters associated with a specific LLM task
+        """
+        return self._task_params
+
+
+class BulletedSummaryParams(LLMTaskParams):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._gen_cfg = GenerationConfig(
+            max_new_tokens=800,
+            num_beams=1,
+            do_sample=True,
+            temperature=0.2,
+            early_stopping=True,
+        )
+        self._instruct = """
+        Given a meeting transcript, extract the key things discussed in the
+         form of a list.
+
+        While generating the response, follow the constraints mentioned below.
+
+        Summary constraints:
+        i) Do not add new content, except to fix spelling or punctuation.
+        ii) Do not add any prefixes or numbering in the response.
+        iii) The summarization should be as information dense as possible.
+        iv) Do not add any additional sections like Note, Conclusion, etc. in
+        the response.
+
+        Response format:
+        i) The response should be in the form of a bulleted list.
+        ii) Iteratively merge all the relevant paragraphs together to keep the
+         number of paragraphs to a minimum.
+        iii) Remove any unfinished sentences from the final response.
+        iv) Do not include narrative or reporting clauses.
+        v) Use "*" as the bullet icon.
+    """
+        self._task_params = TaskParams(
+            instruct=self._instruct, gen_schema=None, gen_cfg=self._gen_cfg
+        )
+
+    def _get_task_params(self) -> TaskParams:
+        """gen_schema
+        Return the parameters associated with a specific LLM task
+        """
+        return self._task_params
+
+
+class MergedSummaryParams(LLMTaskParams):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._gen_cfg = GenerationConfig(
+            max_new_tokens=600,
+            num_beams=1,
+            do_sample=True,
+            temperature=0.2,
+            early_stopping=True,
+        )
+        self._instruct = """
+        Given the key points of a meeting, summarize the points to describe the
+         meeting in the form of paragraphs.
+        """
+        self._task_params = TaskParams(
+            instruct=self._instruct, gen_schema=None, gen_cfg=self._gen_cfg
+        )
+
+    def _get_task_params(self) -> TaskParams:
+        """gen_schema
+        Return the parameters associated with a specific LLM task
+        """
+        return self._task_params
+
+
+LLMTaskParams.register("topic", TopicParams)
+LLMTaskParams.register("final_title", FinalTitleParams)
+LLMTaskParams.register("final_short_summary", FinalShortSummaryParams)
+LLMTaskParams.register("final_long_summary", FinalLongSummaryParams)
+LLMTaskParams.register("bullet_summary", BulletedSummaryParams)
+LLMTaskParams.register("merged_summary", MergedSummaryParams)
--- a/server/reflector/pipelines/main_file_pipeline.py
+++ b/server/reflector/pipelines/main_file_pipeline.py
@@ -1,439 +0,0 @@
-"""
-File-based processing pipeline
-==============================
-
-Optimized pipeline for processing complete audio/video files.
-Uses parallel processing for transcription, diarization, and waveform generation.
-"""
-
-import asyncio
-import uuid
-from pathlib import Path
-
-import av
-import structlog
-from celery import chain, shared_task
-
-from reflector.asynctask import asynctask
-from reflector.db.rooms import rooms_controller
-from reflector.db.transcripts import (
-    SourceKind,
-    Transcript,
-    TranscriptStatus,
-    transcripts_controller,
-)
-from reflector.logger import logger
-from reflector.pipelines.main_live_pipeline import (
-    PipelineMainBase,
-    broadcast_to_sockets,
-    task_cleanup_consent,
-    task_pipeline_post_to_zulip,
-)
-from reflector.processors import (
-    AudioFileWriterProcessor,
-    TranscriptFinalSummaryProcessor,
-    TranscriptFinalTitleProcessor,
-    TranscriptTopicDetectorProcessor,
-)
-from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
-from reflector.processors.file_diarization import FileDiarizationInput
-from reflector.processors.file_diarization_auto import FileDiarizationAutoProcessor
-from reflector.processors.file_transcript import FileTranscriptInput
-from reflector.processors.file_transcript_auto import FileTranscriptAutoProcessor
-from reflector.processors.transcript_diarization_assembler import (
-    TranscriptDiarizationAssemblerInput,
-    TranscriptDiarizationAssemblerProcessor,
-)
-from reflector.processors.types import (
-    DiarizationSegment,
-    TitleSummary,
-)
-from reflector.processors.types import (
-    Transcript as TranscriptType,
-)
-from reflector.settings import settings
-from reflector.storage import get_transcripts_storage
-from reflector.worker.webhook import send_transcript_webhook
-
-
-class EmptyPipeline:
-    """Empty pipeline for processors that need a pipeline reference"""
-
-    def __init__(self, logger: structlog.BoundLogger):
-        self.logger = logger
-
-    def get_pref(self, k, d=None):
-        return d
-
-    async def emit(self, event):
-        pass
-
-
-class PipelineMainFile(PipelineMainBase):
-    """
-    Optimized file processing pipeline.
-    Processes complete audio/video files with parallel execution.
-    """
-
-    logger: structlog.BoundLogger = None
-    empty_pipeline = None
-
-    def __init__(self, transcript_id: str):
-        super().__init__(transcript_id=transcript_id)
-        self.logger = logger.bind(transcript_id=self.transcript_id)
-        self.empty_pipeline = EmptyPipeline(logger=self.logger)
-
-    def _handle_gather_exceptions(self, results: list, operation: str) -> None:
-        """Handle exceptions from asyncio.gather with return_exceptions=True"""
-        for i, result in enumerate(results):
-            if not isinstance(result, Exception):
-                continue
-            self.logger.error(
-                f"Error in {operation} (task {i}): {result}",
-                transcript_id=self.transcript_id,
-                exc_info=result,
-            )
-
-    @broadcast_to_sockets
-    async def set_status(self, transcript_id: str, status: TranscriptStatus):
-        async with self.lock_transaction():
-            return await transcripts_controller.set_status(transcript_id, status)
-
-    async def process(self, file_path: Path):
-        """Main entry point for file processing"""
-        self.logger.info(f"Starting file pipeline for {file_path}")
-
-        transcript = await self.get_transcript()
-
-        # Clear transcript as we're going to regenerate everything
-        async with self.transaction():
-            await transcripts_controller.update(
-                transcript,
-                {
-                    "events": [],
-                    "topics": [],
-                },
-            )
-
-        # Extract audio and write to transcript location
-        audio_path = await self.extract_and_write_audio(file_path, transcript)
-
-        # Upload for processing
-        audio_url = await self.upload_audio(audio_path, transcript)
-
-        # Run parallel processing
-        await self.run_parallel_processing(
-            audio_path,
-            audio_url,
-            transcript.source_language,
-            transcript.target_language,
-        )
-
-        self.logger.info("File pipeline complete")
-
-        await transcripts_controller.set_status(transcript.id, "ended")
-
-    async def extract_and_write_audio(
-        self, file_path: Path, transcript: Transcript
-    ) -> Path:
-        """Extract audio from video if needed and write to transcript location as MP3"""
-        self.logger.info(f"Processing audio file: {file_path}")
-
-        # Check if it's already audio-only
-        container = av.open(str(file_path))
-        has_video = len(container.streams.video) > 0
-        container.close()
-
-        # Use AudioFileWriterProcessor to write MP3 to transcript location
-        mp3_writer = AudioFileWriterProcessor(
-            path=transcript.audio_mp3_filename,
-            on_duration=self.on_duration,
-        )
-
-        # Process audio frames and write to transcript location
-        input_container = av.open(str(file_path))
-        for frame in input_container.decode(audio=0):
-            await mp3_writer.push(frame)
-
-        await mp3_writer.flush()
-        input_container.close()
-
-        if has_video:
-            self.logger.info(
-                f"Extracted audio from video and saved to {transcript.audio_mp3_filename}"
-            )
-        else:
-            self.logger.info(
-                f"Converted audio file and saved to {transcript.audio_mp3_filename}"
-            )
-
-        return transcript.audio_mp3_filename
-
-    async def upload_audio(self, audio_path: Path, transcript: Transcript) -> str:
-        """Upload audio to storage for processing"""
-        storage = get_transcripts_storage()
-
-        if not storage:
-            raise Exception(
-                "Storage backend required for file processing. Configure TRANSCRIPT_STORAGE_* settings."
-            )
-
-        self.logger.info("Uploading audio to storage")
-
-        with open(audio_path, "rb") as f:
-            audio_data = f.read()
-
-        storage_path = f"file_pipeline/{transcript.id}/audio.mp3"
-        await storage.put_file(storage_path, audio_data)
-
-        audio_url = await storage.get_file_url(storage_path)
-
-        self.logger.info(f"Audio uploaded to {audio_url}")
-        return audio_url
-
-    async def run_parallel_processing(
-        self,
-        audio_path: Path,
-        audio_url: str,
-        source_language: str,
-        target_language: str,
-    ):
-        """Coordinate parallel processing of transcription, diarization, and waveform"""
-        self.logger.info(
-            "Starting parallel processing", transcript_id=self.transcript_id
-        )
-
-        # Phase 1: Parallel processing of independent tasks
-        transcription_task = self.transcribe_file(audio_url, source_language)
-        diarization_task = self.diarize_file(audio_url)
-        waveform_task = self.generate_waveform(audio_path)
-
-        results = await asyncio.gather(
-            transcription_task, diarization_task, waveform_task, return_exceptions=True
-        )
-
-        transcript_result = results[0]
-        diarization_result = results[1]
-
-        # Handle errors - raise any exception that occurred
-        self._handle_gather_exceptions(results, "parallel processing")
-        for result in results:
-            if isinstance(result, Exception):
-                raise result
-
-        # Phase 2: Assemble transcript with diarization
-        self.logger.info(
-            "Assembling transcript with diarization", transcript_id=self.transcript_id
-        )
-        processor = TranscriptDiarizationAssemblerProcessor()
-        input_data = TranscriptDiarizationAssemblerInput(
-            transcript=transcript_result, diarization=diarization_result or []
-        )
-
-        # Store result for retrieval
-        diarized_transcript: Transcript | None = None
-
-        async def capture_result(transcript):
-            nonlocal diarized_transcript
-            diarized_transcript = transcript
-
-        processor.on(capture_result)
-        await processor.push(input_data)
-        await processor.flush()
-
-        if not diarized_transcript:
-            raise ValueError("No diarized transcript captured")
-
-        # Phase 3: Generate topics from diarized transcript
-        self.logger.info("Generating topics", transcript_id=self.transcript_id)
-        topics = await self.detect_topics(diarized_transcript, target_language)
-
-        # Phase 4: Generate title and summaries in parallel
-        self.logger.info(
-            "Generating title and summaries", transcript_id=self.transcript_id
-        )
-        results = await asyncio.gather(
-            self.generate_title(topics),
-            self.generate_summaries(topics),
-            return_exceptions=True,
-        )
-
-        self._handle_gather_exceptions(results, "title and summary generation")
-
-    async def transcribe_file(self, audio_url: str, language: str) -> TranscriptType:
-        """Transcribe complete file"""
-        processor = FileTranscriptAutoProcessor()
-        input_data = FileTranscriptInput(audio_url=audio_url, language=language)
-
-        # Store result for retrieval
-        result: TranscriptType | None = None
-
-        async def capture_result(transcript):
-            nonlocal result
-            result = transcript
-
-        processor.on(capture_result)
-        await processor.push(input_data)
-        await processor.flush()
-
-        if not result:
-            raise ValueError("No transcript captured")
-
-        return result
-
-    async def diarize_file(self, audio_url: str) -> list[DiarizationSegment] | None:
-        """Get diarization for file"""
-        if not settings.DIARIZATION_BACKEND:
-            self.logger.info("Diarization disabled")
-            return None
-
-        processor = FileDiarizationAutoProcessor()
-        input_data = FileDiarizationInput(audio_url=audio_url)
-
-        # Store result for retrieval
-        result = None
-
-        async def capture_result(diarization_output):
-            nonlocal result
-            result = diarization_output.diarization
-
-        try:
-            processor.on(capture_result)
-            await processor.push(input_data)
-            await processor.flush()
-            return result
-        except Exception as e:
-            self.logger.error(f"Diarization failed: {e}")
-            return None
-
-    async def generate_waveform(self, audio_path: Path):
-        """Generate and save waveform"""
-        transcript = await self.get_transcript()
-
-        processor = AudioWaveformProcessor(
-            audio_path=audio_path,
-            waveform_path=transcript.audio_waveform_filename,
-            on_waveform=self.on_waveform,
-        )
-        processor.set_pipeline(self.empty_pipeline)
-
-        await processor.flush()
-
-    async def detect_topics(
-        self, transcript: TranscriptType, target_language: str
-    ) -> list[TitleSummary]:
-        """Detect topics from complete transcript"""
-        chunk_size = 300
-        topics: list[TitleSummary] = []
-
-        async def on_topic(topic: TitleSummary):
-            topics.append(topic)
-            return await self.on_topic(topic)
-
-        topic_detector = TranscriptTopicDetectorProcessor(callback=on_topic)
-        topic_detector.set_pipeline(self.empty_pipeline)
-
-        for i in range(0, len(transcript.words), chunk_size):
-            chunk_words = transcript.words[i : i + chunk_size]
-            if not chunk_words:
-                continue
-
-            chunk_transcript = TranscriptType(
-                words=chunk_words, translation=transcript.translation
-            )
-
-            await topic_detector.push(chunk_transcript)
-
-        await topic_detector.flush()
-        return topics
-
-    async def generate_title(self, topics: list[TitleSummary]):
-        """Generate title from topics"""
-        if not topics:
-            self.logger.warning("No topics for title generation")
-            return
-
-        processor = TranscriptFinalTitleProcessor(callback=self.on_title)
-        processor.set_pipeline(self.empty_pipeline)
-
-        for topic in topics:
-            await processor.push(topic)
-
-        await processor.flush()
-
-    async def generate_summaries(self, topics: list[TitleSummary]):
-        """Generate long and short summaries from topics"""
-        if not topics:
-            self.logger.warning("No topics for summary generation")
-            return
-
-        transcript = await self.get_transcript()
-        processor = TranscriptFinalSummaryProcessor(
-            transcript=transcript,
-            callback=self.on_long_summary,
-            on_short_summary=self.on_short_summary,
-        )
-        processor.set_pipeline(self.empty_pipeline)
-
-        for topic in topics:
-            await processor.push(topic)
-
-        await processor.flush()
-
-
-@shared_task
-@asynctask
-async def task_send_webhook_if_needed(*, transcript_id: str):
-    """Send webhook if this is a room recording with webhook configured"""
-    transcript = await transcripts_controller.get_by_id(transcript_id)
-    if not transcript:
-        return
-
-    if transcript.source_kind == SourceKind.ROOM and transcript.room_id:
-        room = await rooms_controller.get_by_id(transcript.room_id)
-        if room and room.webhook_url:
-            logger.info(
-                "Dispatching webhook",
-                transcript_id=transcript_id,
-                room_id=room.id,
-                webhook_url=room.webhook_url,
-            )
-            send_transcript_webhook.delay(
-                transcript_id, room.id, event_id=uuid.uuid4().hex
-            )
-
-
-@shared_task
-@asynctask
-async def task_pipeline_file_process(*, transcript_id: str):
-    """Celery task for file pipeline processing"""
-
-    transcript = await transcripts_controller.get_by_id(transcript_id)
-    if not transcript:
-        raise Exception(f"Transcript {transcript_id} not found")
-
-    pipeline = PipelineMainFile(transcript_id=transcript_id)
-    try:
-        await pipeline.set_status(transcript_id, "processing")
-
-        # Find the file to process
-        audio_file = next(transcript.data_path.glob("upload.*"), None)
-        if not audio_file:
-            audio_file = next(transcript.data_path.glob("audio.*"), None)
-
-        if not audio_file:
-            raise Exception("No audio file found to process")
-
-        await pipeline.process(audio_file)
-
-    except Exception:
-        await pipeline.set_status(transcript_id, "error")
-        raise
-
-    # Run post-processing chain: consent cleanup -> zulip -> webhook
-    post_chain = chain(
-        task_cleanup_consent.si(transcript_id=transcript_id),
-        task_pipeline_post_to_zulip.si(transcript_id=transcript_id),
-        task_send_webhook_if_needed.si(transcript_id=transcript_id),
-    )
-    post_chain.delay()
--- a/server/reflector/pipelines/main_live_pipeline.py
+++ b/server/reflector/pipelines/main_live_pipeline.py
@@ -14,15 +14,10 @@ It is directly linked to our data model.
 import asyncio
 import functools
 from contextlib import asynccontextmanager
-from typing import Generic

-import av
 import boto3
-from celery import chord, current_task, group, shared_task
+from celery import chord, group, shared_task
 from pydantic import BaseModel
-from structlog import BoundLogger as Logger
-
-from reflector.asynctask import asynctask
 from reflector.db.meetings import meeting_consent_controller, meetings_controller
 from reflector.db.recordings import recordings_controller
 from reflector.db.rooms import rooms_controller
@@ -32,18 +27,16 @@ from reflector.db.transcripts import (
    TranscriptFinalLongSummary,
    TranscriptFinalShortSummary,
    TranscriptFinalTitle,
-    TranscriptStatus,
    TranscriptText,
    TranscriptTopic,
    TranscriptWaveform,
    transcripts_controller,
 )
 from reflector.logger import logger
-from reflector.pipelines.runner import PipelineMessage, PipelineRunner
+from reflector.pipelines.runner import PipelineRunner
 from reflector.processors import (
-    AudioChunkerAutoProcessor,
+    AudioChunkerProcessor,
    AudioDiarizationAutoProcessor,
-    AudioDownscaleProcessor,
    AudioFileWriterProcessor,
    AudioMergeProcessor,
    AudioTranscriptAutoProcessor,
@@ -52,7 +45,7 @@ from reflector.processors import (
    TranscriptFinalTitleProcessor,
    TranscriptLinerProcessor,
    TranscriptTopicDetectorProcessor,
-    TranscriptTranslatorAutoProcessor,
+    TranscriptTranslatorProcessor,
 )
 from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
 from reflector.processors.types import AudioDiarizationInput
@@ -68,6 +61,31 @@ from reflector.zulip import (
    send_message_to_zulip,
    update_zulip_message,
 )
+from structlog import BoundLogger as Logger
+
+
+def asynctask(f):
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        async def run_with_db():
+            from reflector.db import database
+
+            await database.connect()
+            try:
+                return await f(*args, **kwargs)
+            finally:
+                await database.disconnect()
+
+        coro = run_with_db()
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop and loop.is_running():
+            return loop.run_until_complete(coro)
+        return asyncio.run(coro)
+
+    return wrapper


 def broadcast_to_sockets(func):
@@ -93,29 +111,16 @@ def get_transcript(func):
    Decorator to fetch the transcript from the database from the first argument
    """

-    @functools.wraps(func)
    async def wrapper(**kwargs):
        transcript_id = kwargs.pop("transcript_id")
        transcript = await transcripts_controller.get_by_id(transcript_id=transcript_id)
        if not transcript:
            raise Exception("Transcript {transcript_id} not found")
-
-        # Enhanced logger with Celery task context
        tlogger = logger.bind(transcript_id=transcript.id)
-        if current_task:
-            tlogger = tlogger.bind(
-                task_id=current_task.request.id,
-                task_name=current_task.name,
-                worker_hostname=current_task.request.hostname,
-                task_retries=current_task.request.retries,
-                transcript_id=transcript_id,
-            )
-
        try:
-            result = await func(transcript=transcript, logger=tlogger, **kwargs)
-            return result
+            return await func(transcript=transcript, logger=tlogger, **kwargs)
        except Exception as exc:
-            tlogger.error("Pipeline error", function_name=func.__name__, exc_info=exc)
+            tlogger.error("Pipeline error", exc_info=exc)
            raise

    return wrapper
@@ -125,19 +130,16 @@ class StrValue(BaseModel):
    value: str


-class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]):
-    def __init__(self, transcript_id: str):
-        super().__init__()
-        self._lock = asyncio.Lock()
-        self.transcript_id = transcript_id
-        self.ws_room_id = f"ts:{self.transcript_id}"
-        self._ws_manager = None
+class PipelineMainBase(PipelineRunner):
+    transcript_id: str
+    ws_room_id: str | None = None
+    ws_manager: WebsocketManager | None = None

-    @property
-    def ws_manager(self) -> WebsocketManager:
-        if self._ws_manager is None:
-            self._ws_manager = get_ws_manager()
-        return self._ws_manager
+    def prepare(self):
+        # prepare websocket
+        self._lock = asyncio.Lock()
+        self.ws_room_id = f"ts:{self.transcript_id}"
+        self.ws_manager = get_ws_manager()

    async def get_transcript(self) -> Transcript:
        # fetch the transcript
@@ -148,11 +150,7 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
            raise Exception("Transcript not found")
        return result

-    @staticmethod
-    def wrap_transcript_topics(
-        topics: list[TranscriptTopic],
-    ) -> list[TitleSummaryWithIdProcessorType]:
-        # transformation to a pipe-supported format
+    def get_transcript_topics(self, transcript: Transcript) -> list[TranscriptTopic]:
        return [
            TitleSummaryWithIdProcessorType(
                id=topic.id,
@@ -162,19 +160,12 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
                duration=topic.duration,
                transcript=TranscriptProcessorType(words=topic.words),
            )
-            for topic in topics
+            for topic in transcript.topics
        ]

-    @asynccontextmanager
-    async def lock_transaction(self):
-        # This lock is to prevent multiple processor starting adding
-        # into event array at the same time
-        async with self._lock:
-            yield
-
    @asynccontextmanager
    async def transaction(self):
-        async with self.lock_transaction():
+        async with self._lock:
            async with transcripts_controller.transaction():
                yield

@@ -183,14 +174,14 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
        # if it's the first part, update the status of the transcript
        # but do not set the ended status yet.
        if isinstance(self, PipelineMainLive):
-            status_mapping: dict[str, TranscriptStatus] = {
+            status_mapping = {
                "started": "recording",
                "push": "recording",
                "flush": "processing",
                "error": "error",
            }
        elif isinstance(self, PipelineMainFinalSummaries):
-            status_mapping: dict[str, TranscriptStatus] = {
+            status_mapping = {
                "push": "processing",
                "flush": "processing",
                "error": "error",
@@ -206,8 +197,22 @@ class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]
            return

        # when the status of the pipeline changes, update the transcript
-        async with self._lock:
-            return await transcripts_controller.set_status(self.transcript_id, status)
+        async with self.transaction():
+            transcript = await self.get_transcript()
+            if status == transcript.status:
+                return
+            resp = await transcripts_controller.append_event(
+                transcript=transcript,
+                event="STATUS",
+                data=StrValue(value=status),
+            )
+            await transcripts_controller.update(
+                transcript,
+                {
+                    "status": status,
+                },
+            )
+            return resp

    @broadcast_to_sockets
    async def on_transcript(self, data):
@@ -330,6 +335,7 @@ class PipelineMainLive(PipelineMainBase):
    async def create(self) -> Pipeline:
        # create a context for the whole rtc transaction
        # add a customised logger to the context
+        self.prepare()
        transcript = await self.get_transcript()

        processors = [
@@ -337,12 +343,11 @@ class PipelineMainLive(PipelineMainBase):
                path=transcript.audio_wav_filename,
                on_duration=self.on_duration,
            ),
-            AudioDownscaleProcessor(),
-            AudioChunkerAutoProcessor(),
+            AudioChunkerProcessor(),
            AudioMergeProcessor(),
            AudioTranscriptAutoProcessor.as_threaded(),
            TranscriptLinerProcessor(),
-            TranscriptTranslatorAutoProcessor.as_threaded(callback=self.on_transcript),
+            TranscriptTranslatorProcessor.as_threaded(callback=self.on_transcript),
            TranscriptTopicDetectorProcessor.as_threaded(callback=self.on_topic),
        ]
        pipeline = Pipeline(*processors)
@@ -351,7 +356,6 @@ class PipelineMainLive(PipelineMainBase):
        pipeline.set_pref("audio:target_language", transcript.target_language)
        pipeline.logger.bind(transcript_id=transcript.id)
        pipeline.logger.info("Pipeline main live created")
-        pipeline.describe()

        return pipeline

@@ -362,7 +366,7 @@ class PipelineMainLive(PipelineMainBase):
        pipeline_post(transcript_id=self.transcript_id)


-class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
+class PipelineMainDiarization(PipelineMainBase):
    """
    Diarize the audio and update topics
    """
@@ -370,6 +374,7 @@ class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
    async def create(self) -> Pipeline:
        # create a context for the whole rtc transaction
        # add a customised logger to the context
+        self.prepare()
        pipeline = Pipeline(
            AudioDiarizationAutoProcessor(callback=self.on_topic),
        )
@@ -385,10 +390,11 @@ class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
            pipeline.logger.info("Audio is local, skipping diarization")
            return

+        topics = self.get_transcript_topics(transcript)
        audio_url = await transcript.get_audio_url()
        audio_diarization_input = AudioDiarizationInput(
            audio_url=audio_url,
-            topics=self.wrap_transcript_topics(transcript.topics),
+            topics=topics,
        )

        # as tempting to use pipeline.push, prefer to use the runner
@@ -401,7 +407,7 @@ class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
        return pipeline


-class PipelineMainFromTopics(PipelineMainBase[TitleSummaryWithIdProcessorType]):
+class PipelineMainFromTopics(PipelineMainBase):
    """
    Pseudo class for generating a pipeline from topics
    """
@@ -410,6 +416,8 @@ class PipelineMainFromTopics(PipelineMainBase[TitleSummaryWithIdProcessorType]):
        raise NotImplementedError

    async def create(self) -> Pipeline:
+        self.prepare()
+
        # get transcript
        self._transcript = transcript = await self.get_transcript()

@@ -421,7 +429,7 @@ class PipelineMainFromTopics(PipelineMainBase[TitleSummaryWithIdProcessorType]):
        pipeline.logger.info(f"{self.__class__.__name__} pipeline created")

        # push topics
-        topics = PipelineMainBase.wrap_transcript_topics(transcript.topics)
+        topics = self.get_transcript_topics(transcript)
        for topic in topics:
            await self.push(topic)

@@ -446,15 +454,47 @@ class PipelineMainFinalSummaries(PipelineMainFromTopics):
    Generate summaries from the topics
    """

+    async def get_room(self):
+        """Get room information for the transcript"""
+        if not self._transcript.room_id:
+            return None
+        return await rooms_controller.get_by_id(self._transcript.room_id)
+
    def get_processors(self) -> list:
        return [
            TranscriptFinalSummaryProcessor.as_threaded(
                transcript=self._transcript,
+                room=getattr(self, '_room', None),
                callback=self.on_long_summary,
                on_short_summary=self.on_short_summary,
            ),
        ]

+    async def create(self) -> Pipeline:
+        self.prepare()
+
+        # get transcript
+        self._transcript = transcript = await self.get_transcript()
+        
+        # get room information
+        self._room = await self.get_room()
+
+        # create pipeline
+        processors = self.get_processors()
+        pipeline = Pipeline(*processors)
+        pipeline.options = self
+        pipeline.logger.bind(transcript_id=transcript.id)
+        pipeline.logger.info(f"{self.__class__.__name__} pipeline created")
+
+        # push topics
+        topics = self.get_transcript_topics(transcript)
+        for topic in topics:
+            await self.push(topic)
+
+        await self.flush()
+
+        return pipeline
+

 class PipelineMainWaveform(PipelineMainFromTopics):
    """
@@ -502,6 +542,8 @@ async def pipeline_convert_to_mp3(transcript: Transcript, logger: Logger):
    # Convert to mp3
    mp3_filename = transcript.audio_mp3_filename

+    import av
+
    with av.open(wav_filename.as_posix()) as in_container:
        in_stream = in_container.streams.audio[0]
        with av.open(mp3_filename.as_posix(), "w") as out_container:
@@ -580,7 +622,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                        meeting.id
                    )
    except Exception as e:
-        logger.error(f"Failed to get fetch consent: {e}", exc_info=e)
+        logger.error(f"Failed to get fetch consent: {e}")
        consent_denied = True

    if not consent_denied:
@@ -603,7 +645,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                f"Deleted original Whereby recording: {recording.bucket_name}/{recording.object_key}"
            )
        except Exception as e:
-            logger.error(f"Failed to delete Whereby recording: {e}", exc_info=e)
+            logger.error(f"Failed to delete Whereby recording: {e}")

    # non-transactional, files marked for deletion not actually deleted is possible
    await transcripts_controller.update(transcript, {"audio_deleted": True})
@@ -616,7 +658,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                f"Deleted processed audio from storage: {transcript.storage_audio_path}"
            )
        except Exception as e:
-            logger.error(f"Failed to delete processed audio: {e}", exc_info=e)
+            logger.error(f"Failed to delete processed audio: {e}")

    # 3. Delete local audio files
    try:
@@ -625,7 +667,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
        if hasattr(transcript, "audio_wav_filename") and transcript.audio_wav_filename:
            transcript.audio_wav_filename.unlink(missing_ok=True)
    except Exception as e:
-        logger.error(f"Failed to delete local audio files: {e}", exc_info=e)
+        logger.error(f"Failed to delete local audio files: {e}")

    logger.info("Consent cleanup done")

@@ -765,11 +807,13 @@ def pipeline_post(*, transcript_id: str):
        chain_final_summaries,
    ) | task_pipeline_post_to_zulip.si(transcript_id=transcript_id)

-    return chain.delay()
+    chain.delay()


@get_transcript
 async def pipeline_process(transcript: Transcript, logger: Logger):
+    import av
+
    try:
        if transcript.audio_location == "storage":
            await transcripts_controller.download_mp3_from_storage(transcript)
--- a/server/reflector/pipelines/runner.py
+++ b/server/reflector/pipelines/runner.py
@@ -16,16 +16,20 @@ During its lifecycle, it will emit the following status:
 """

 import asyncio
-from typing import Generic, TypeVar

+from pydantic import BaseModel, ConfigDict
 from reflector.logger import logger
 from reflector.processors import Pipeline

-PipelineMessage = TypeVar("PipelineMessage")

+class PipelineRunner(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)

-class PipelineRunner(Generic[PipelineMessage]):
-    def __init__(self):
+    status: str = "idle"
+    pipeline: Pipeline | None = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
        self._task = None
        self._q_cmd = asyncio.Queue(maxsize=4096)
        self._ev_done = asyncio.Event()
@@ -34,8 +38,6 @@ class PipelineRunner(Generic[PipelineMessage]):
            runner=id(self),
            runner_cls=self.__class__.__name__,
        )
-        self.status = "idle"
-        self.pipeline: Pipeline | None = None

    async def create(self) -> Pipeline:
        """
@@ -64,7 +66,7 @@ class PipelineRunner(Generic[PipelineMessage]):
        coro = self.run()
        asyncio.run(coro)

-    async def push(self, data: PipelineMessage):
+    async def push(self, data):
        """
        Push data to the pipeline
        """
@@ -89,11 +91,7 @@ class PipelineRunner(Generic[PipelineMessage]):
        pass

    async def _add_cmd(
-        self,
-        cmd: str,
-        data: PipelineMessage,
-        max_retries: int = 3,
-        retry_time_limit: int = 3,
+        self, cmd: str, data, max_retries: int = 3, retry_time_limit: int = 3
    ):
        """
        Enqueue a command to be executed in the runner.
@@ -144,10 +142,7 @@ class PipelineRunner(Generic[PipelineMessage]):
                cmd, data = await self._q_cmd.get()
                func = getattr(self, f"cmd_{cmd.lower()}")
                if func:
-                    if cmd.upper() == "FLUSH":
-                        await func()
-                    else:
-                        await func(data)
+                    await func(data)
                else:
                    raise Exception(f"Unknown command {cmd}")
        except Exception:
@@ -156,13 +151,13 @@ class PipelineRunner(Generic[PipelineMessage]):
            self._ev_done.set()
            raise

-    async def cmd_push(self, data: PipelineMessage):
+    async def cmd_push(self, data):
        if self._is_first_push:
            await self._set_status("push")
            self._is_first_push = False
        await self.pipeline.push(data)

-    async def cmd_flush(self):
+    async def cmd_flush(self, data):
        await self._set_status("flush")
        await self.pipeline.flush()
        await self._set_status("ended")
--- a/server/reflector/processors/init.py
+++ b/server/reflector/processors/init.py
@@ -1,7 +1,5 @@
 from .audio_chunker import AudioChunkerProcessor  # noqa: F401
-from .audio_chunker_auto import AudioChunkerAutoProcessor  # noqa: F401
 from .audio_diarization_auto import AudioDiarizationAutoProcessor  # noqa: F401
-from .audio_downscale import AudioDownscaleProcessor  # noqa: F401
 from .audio_file_writer import AudioFileWriterProcessor  # noqa: F401
 from .audio_merge import AudioMergeProcessor  # noqa: F401
 from .audio_transcript import AudioTranscriptProcessor  # noqa: F401
@@ -13,19 +11,11 @@ from .base import (  # noqa: F401
    Processor,
    ThreadedProcessor,
 )
-from .file_diarization import FileDiarizationProcessor  # noqa: F401
-from .file_diarization_auto import FileDiarizationAutoProcessor  # noqa: F401
-from .file_transcript import FileTranscriptProcessor  # noqa: F401
-from .file_transcript_auto import FileTranscriptAutoProcessor  # noqa: F401
-from .transcript_diarization_assembler import (
-    TranscriptDiarizationAssemblerProcessor,  # noqa: F401
-)
 from .transcript_final_summary import TranscriptFinalSummaryProcessor  # noqa: F401
 from .transcript_final_title import TranscriptFinalTitleProcessor  # noqa: F401
 from .transcript_liner import TranscriptLinerProcessor  # noqa: F401
 from .transcript_topic_detector import TranscriptTopicDetectorProcessor  # noqa: F401
 from .transcript_translator import TranscriptTranslatorProcessor  # noqa: F401
-from .transcript_translator_auto import TranscriptTranslatorAutoProcessor  # noqa: F401
 from .types import (  # noqa: F401
    AudioFile,
    FinalLongSummary,
--- a/server/reflector/processors/audio_chunker.py
+++ b/server/reflector/processors/audio_chunker.py
@@ -1,78 +1,27 @@
-from typing import Optional
-
-import av
-from prometheus_client import Counter, Histogram
-
 from reflector.processors.base import Processor
+import av


 class AudioChunkerProcessor(Processor):
    """
-    Base class for assembling audio frames into chunks
+    Assemble audio frames into chunks
    """

    INPUT_TYPE = av.AudioFrame
    OUTPUT_TYPE = list[av.AudioFrame]

-    m_chunk = Histogram(
-        "audio_chunker",
-        "Time spent in AudioChunker.chunk",
-        ["backend"],
-    )
-    m_chunk_call = Counter(
-        "audio_chunker_call",
-        "Number of calls to AudioChunker.chunk",
-        ["backend"],
-    )
-    m_chunk_success = Counter(
-        "audio_chunker_success",
-        "Number of successful calls to AudioChunker.chunk",
-        ["backend"],
-    )
-    m_chunk_failure = Counter(
-        "audio_chunker_failure",
-        "Number of failed calls to AudioChunker.chunk",
-        ["backend"],
-    )
-
-    def __init__(self, *args, **kwargs):
-        name = self.__class__.__name__
-        self.m_chunk = self.m_chunk.labels(name)
-        self.m_chunk_call = self.m_chunk_call.labels(name)
-        self.m_chunk_success = self.m_chunk_success.labels(name)
-        self.m_chunk_failure = self.m_chunk_failure.labels(name)
-        super().__init__(*args, **kwargs)
+    def __init__(self, max_frames=256):
+        super().__init__()
        self.frames: list[av.AudioFrame] = []
+        self.max_frames = max_frames

    async def _push(self, data: av.AudioFrame):
-        """Process incoming audio frame"""
-        # Validate audio format on first frame
-        if len(self.frames) == 0:
-            if data.sample_rate != 16000 or len(data.layout.channels) != 1:
-                raise ValueError(
-                    f"AudioChunkerProcessor expects 16kHz mono audio, got {data.sample_rate}Hz "
-                    f"with {len(data.layout.channels)} channel(s). "
-                    f"Use AudioDownscaleProcessor before this processor."
-                )
-
-        try:
-            self.m_chunk_call.inc()
-            with self.m_chunk.time():
-                result = await self._chunk(data)
-            self.m_chunk_success.inc()
-            if result:
-                await self.emit(result)
-        except Exception:
-            self.m_chunk_failure.inc()
-            raise
-
-    async def _chunk(self, data: av.AudioFrame) -> Optional[list[av.AudioFrame]]:
-        """
-        Process audio frame and return chunk when ready.
-        Subclasses should implement their chunking logic here.
-        """
-        raise NotImplementedError
+        self.frames.append(data)
+        if len(self.frames) >= self.max_frames:
+            await self.flush()

    async def _flush(self):
-        """Flush any remaining frames when processing ends"""
-        raise NotImplementedError
+        frames = self.frames[:]
+        self.frames = []
+        if frames:
+            await self.emit(frames)
--- a/server/reflector/processors/audio_chunker_auto.py
+++ b/server/reflector/processors/audio_chunker_auto.py
@@ -1,32 +0,0 @@
-import importlib
-
-from reflector.processors.audio_chunker import AudioChunkerProcessor
-from reflector.settings import settings
-
-
-class AudioChunkerAutoProcessor(AudioChunkerProcessor):
-    _registry = {}
-
-    @classmethod
-    def register(cls, name, kclass):
-        cls._registry[name] = kclass
-
-    def __new__(cls, name: str | None = None, **kwargs):
-        if name is None:
-            name = settings.AUDIO_CHUNKER_BACKEND
-        if name not in cls._registry:
-            module_name = f"reflector.processors.audio_chunker_{name}"
-            importlib.import_module(module_name)
-
-        # gather specific configuration for the processor
-        # search `AUDIO_CHUNKER_BACKEND_XXX_YYY`, push to constructor as `backend_xxx_yyy`
-        config = {}
-        name_upper = name.upper()
-        settings_prefix = "AUDIO_CHUNKER_"
-        config_prefix = f"{settings_prefix}{name_upper}_"
-        for key, value in settings:
-            if key.startswith(config_prefix):
-                config_name = key[len(settings_prefix) :].lower()
-                config[config_name] = value
-
-        return cls._registry[name](**config | kwargs)
--- a/server/reflector/processors/audio_chunker_frames.py
+++ b/server/reflector/processors/audio_chunker_frames.py
@@ -1,34 +0,0 @@
-from typing import Optional
-
-import av
-
-from reflector.processors.audio_chunker import AudioChunkerProcessor
-from reflector.processors.audio_chunker_auto import AudioChunkerAutoProcessor
-
-
-class AudioChunkerFramesProcessor(AudioChunkerProcessor):
-    """
-    Simple frame-based audio chunker that emits chunks after a fixed number of frames
-    """
-
-    def __init__(self, max_frames=256, **kwargs):
-        super().__init__(**kwargs)
-        self.max_frames = max_frames
-
-    async def _chunk(self, data: av.AudioFrame) -> Optional[list[av.AudioFrame]]:
-        self.frames.append(data)
-        if len(self.frames) >= self.max_frames:
-            frames_to_emit = self.frames[:]
-            self.frames = []
-            return frames_to_emit
-
-        return None
-
-    async def _flush(self):
-        frames = self.frames[:]
-        self.frames = []
-        if frames:
-            await self.emit(frames)
-
-
-AudioChunkerAutoProcessor.register("frames", AudioChunkerFramesProcessor)
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`b9d891d3424f371642cb032ecfd0e2564470a72c:server/tests/test_transcripts_recording_deletion.py:generic-api-key:15`