feat: implement frontend for calendar integration (Phase 3 & 4)

## Frontend Implementation

### Meeting Selection & Management
- Created MeetingSelection component for choosing between multiple active meetings
- Shows both active meetings and upcoming calendar events (30 min ahead)
- Displays meeting metadata with privacy controls (owner-only details)
- Supports creation of unscheduled meetings alongside calendar meetings

### Waiting Room
- Added waiting page for users joining before scheduled start time
- Shows countdown timer until meeting begins
- Auto-transitions to meeting when calendar event becomes active
- Handles early joining with proper routing

### Meeting Info Panel
- Created collapsible info panel showing meeting details
- Displays calendar metadata (title, description, attendees)
- Shows participant count and duration
- Privacy-aware: sensitive info only visible to room owners

### ICS Configuration UI
- Integrated ICS settings into room configuration dialog
- Test connection functionality with immediate feedback
- Manual sync trigger with detailed results
- Shows last sync time and ETag for monitoring
- Configurable sync intervals (1 min to 1 hour)

### Routing & Navigation
- New /room/{roomName} route for meeting selection
- Waiting room at /room/{roomName}/wait?eventId={id}
- Classic room page at /{roomName} with meeting info
- Uses sessionStorage to pass selected meeting between pages

### API Integration
- Added new endpoints for active/upcoming meetings
- Regenerated TypeScript client with latest OpenAPI spec
- Proper error handling and loading states
- Auto-refresh every 30 seconds for live updates

### UI/UX Improvements
- Color-coded badges for meeting status
- Attendee status indicators (accepted/declined/tentative)
- Responsive design with Chakra UI components
- Clear visual hierarchy between active and upcoming meetings
- Smart truncation for long attendee lists

This completes the frontend implementation for calendar integration,
enabling users to seamlessly join scheduled meetings from their
calendar applications.

.github/pull_request_template.md

@@ -1,19 +1,21 @@
-## ⚠️ Insert the PR TITLE replacing this text ⚠️
+<!--- Provide a general summary of your changes in the Title above -->
 
-⚠️ Describe your PR replacing this text. Post screenshots or videos whenever possible. ⚠️
+## Description
+<!--- Describe your changes in detail -->
 
-### Checklist
+## 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: -->
 
- - [ ] 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
+## 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. -->
 
-> 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)
+## 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. -->
 
+## Screenshots (if appropriate):

.github/workflows/conventional_commit_pr.yml

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

.github/workflows/db_migrations.yml

@@ -17,10 +17,40 @@ on:
 jobs:
   test-migrations:
     runs-on: ubuntu-latest
+    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:

.github/workflows/pre-commit.yml

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

.gitignore

@@ -11,3 +11,7 @@ ngrok.log
 restart-dev.sh
 *.log
 data/
+www/REFACTOR.md
+www/reload-frontend
+server/test.sqlite
+CLAUDE.local.md

.pre-commit-config.yaml

@@ -3,10 +3,10 @@
 repos:
   - repo: local
     hooks:
-      - id: yarn-format
-        name: run yarn format
+      - id: format
+        name: run format
         language: system
-        entry: bash -c 'cd www && yarn format'
+        entry: bash -c 'cd www && pnpm format'
         pass_filenames: false
         files: ^www/
 
@@ -15,25 +15,15 @@ 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.6.5
+    rev: v0.8.2
     hooks:
       - id: ruff
-        files: ^server/(reflector|tests)/
+        args:
+          - --fix
+          # Uses select rules from server/pyproject.toml
+        files: ^server/
+      - id: ruff-format
+        files: ^server/

CHANGELOG.md

@@ -1,5 +1,99 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* Diarization cli ([#509](https://github.com/Monadical-SAS/reflector/issues/509)) ([ffc8003](https://github.com/Monadical-SAS/reflector/commit/ffc8003e6dad236930a27d0fe3e2f2adfb793890))
+
+
+### Bug Fixes
+
+* remove faulty import Meeting ([#512](https://github.com/Monadical-SAS/reflector/issues/512)) ([0e68c79](https://github.com/Monadical-SAS/reflector/commit/0e68c798434e1b481f9482cc3a4702ea00365df4))
+* room concurrency (theoretically) ([#511](https://github.com/Monadical-SAS/reflector/issues/511)) ([7bb3676](https://github.com/Monadical-SAS/reflector/commit/7bb367653afeb2778cff697a0eb217abf0b81b84))
+
+## [0.3.2](https://github.com/Monadical-SAS/reflector/compare/v0.3.1...v0.3.2) (2025-07-22)
+
+
+### Bug Fixes
+
+* match font size for the filter sidebar ([#507](https://github.com/Monadical-SAS/reflector/issues/507)) ([4b8ba5d](https://github.com/Monadical-SAS/reflector/commit/4b8ba5db1733557e27b098ad3d1cdecadf97ae52))
+* whereby consent not displaying ([#505](https://github.com/Monadical-SAS/reflector/issues/505)) ([1120552](https://github.com/Monadical-SAS/reflector/commit/1120552c2c83d084d3a39272ad49b6aeda1af98f))
+
+## [0.3.1](https://github.com/Monadical-SAS/reflector/compare/v0.3.0...v0.3.1) (2025-07-22)
+
+
+### Bug Fixes
+
+* remove fief out of the source code ([#502](https://github.com/Monadical-SAS/reflector/issues/502)) ([890dd15](https://github.com/Monadical-SAS/reflector/commit/890dd15ba5a2be10dbb841e9aeb75d377885f4af))
+* remove primary color for room action menu ([#504](https://github.com/Monadical-SAS/reflector/issues/504)) ([2e33f89](https://github.com/Monadical-SAS/reflector/commit/2e33f89c0f9e5fbaafa80e8d2ae9788450ea2f31))
+
+## [0.3.0](https://github.com/Monadical-SAS/reflector/compare/v0.2.1...v0.3.0) (2025-07-21)
+
+
+### Features
+
+* migrate from chakra 2 to chakra 3 ([#500](https://github.com/Monadical-SAS/reflector/issues/500)) ([a858464](https://github.com/Monadical-SAS/reflector/commit/a858464c7a80e5497acf801d933bf04092f8b526))
+
+## [0.2.1](https://github.com/Monadical-SAS/reflector/compare/v0.2.0...v0.2.1) (2025-07-18)
+
+
+### Bug Fixes
+
+* separate browsing page into different components, limit to 10 by default ([#498](https://github.com/Monadical-SAS/reflector/issues/498)) ([c752da6](https://github.com/Monadical-SAS/reflector/commit/c752da6b97c96318aff079a5b2a6eceadfbfcad1))
+
+## [0.2.0](https://github.com/Monadical-SAS/reflector/compare/0.1.1...v0.2.0) (2025-07-17)
+
+
+### Features
+
+* improve transcript listing with room_id ([#496](https://github.com/Monadical-SAS/reflector/issues/496)) ([d2b5de5](https://github.com/Monadical-SAS/reflector/commit/d2b5de543fc0617fc220caa6a8a290e4040cb10b))
+
+
+### Bug Fixes
+
+* don't attempt to load waveform/mp3 if audio was deleted ([#495](https://github.com/Monadical-SAS/reflector/issues/495)) ([f4578a7](https://github.com/Monadical-SAS/reflector/commit/f4578a743fd0f20312fbd242fa9cccdfaeb20a9e))
+
 ## [0.1.1](https://github.com/Monadical-SAS/reflector/compare/0.1.0...v0.1.1) (2025-07-17)
 
 

CLAUDE.md

@@ -62,7 +62,7 @@ uv run python -m reflector.tools.process path/to/audio.wav
 **Setup:**
 ```bash
 # Install dependencies
-yarn install
+pnpm install
 
 # Copy configuration templates
 cp .env_template .env
@@ -72,19 +72,19 @@ cp config-template.ts config.ts
 **Development:**
 ```bash
 # Start development server
-yarn dev
+pnpm dev
 
 # Generate TypeScript API client from OpenAPI spec
-yarn openapi
+pnpm openapi
 
 # Lint code
-yarn lint
+pnpm lint
 
 # Format code
-yarn format
+pnpm format
 
 # Build for production
-yarn build
+pnpm build
 ```
 
 ### Docker Compose (Full Stack)
@@ -144,9 +144,11 @@ All endpoints prefixed `/v1/`:
 **Backend** (`server/.env`):
 - `DATABASE_URL` - Database connection string
 - `REDIS_URL` - Redis broker for Celery
-- `MODAL_TOKEN_ID`, `MODAL_TOKEN_SECRET` - Modal.com GPU processing
+- `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
 - `WHEREBY_API_KEY` - Video platform integration
-- `REFLECTOR_AUTH_BACKEND` - Authentication method (none, fief, jwt)
+- `REFLECTOR_AUTH_BACKEND` - Authentication method (none, jwt)
 
 **Frontend** (`www/.env`):
 - `NEXTAUTH_URL`, `NEXTAUTH_SECRET` - Authentication configuration
@@ -172,3 +174,7 @@ 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.

ICS_IMPLEMENTATION.md

@@ -0,0 +1,497 @@
+# ICS Calendar Integration - Implementation Guide
+
+## Overview
+This document provides detailed implementation guidance for integrating ICS calendar feeds with Reflector rooms. Unlike CalDAV which requires complex authentication and protocol handling, ICS integration uses simple HTTP(S) fetching of calendar files.
+
+## Key Differences from CalDAV Approach
+
+| Aspect | CalDAV | ICS |
+|--------|--------|-----|
+| Protocol | WebDAV extension | HTTP/HTTPS GET |
+| Authentication | Username/password, OAuth | Tokens embedded in URL |
+| Data Access | Selective event queries | Full calendar download |
+| Implementation | Complex (caldav library) | Simple (requests + icalendar) |
+| Real-time Updates | Supported | Polling only |
+| Write Access | Yes | No (read-only) |
+
+## Technical Architecture
+
+### 1. ICS Fetching Service
+
+```python
+# reflector/services/ics_sync.py
+
+import requests
+from icalendar import Calendar
+from typing import List, Optional
+from datetime import datetime, timedelta
+
+class ICSFetchService:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({'User-Agent': 'Reflector/1.0'})
+
+    def fetch_ics(self, url: str) -> str:
+        """Fetch ICS file from URL (authentication via URL token if needed)."""
+        response = self.session.get(url, timeout=30)
+        response.raise_for_status()
+        return response.text
+
+    def parse_ics(self, ics_content: str) -> Calendar:
+        """Parse ICS content into calendar object."""
+        return Calendar.from_ical(ics_content)
+
+    def extract_room_events(self, calendar: Calendar, room_url: str) -> List[dict]:
+        """Extract events that match the room URL."""
+        events = []
+
+        for component in calendar.walk():
+            if component.name == "VEVENT":
+                # Check if event matches this room
+                if self._event_matches_room(component, room_url):
+                    events.append(self._parse_event(component))
+
+        return events
+
+    def _event_matches_room(self, event, room_url: str) -> bool:
+        """Check if event location or description contains room URL."""
+        location = str(event.get('LOCATION', ''))
+        description = str(event.get('DESCRIPTION', ''))
+
+        # Support various URL formats
+        patterns = [
+            room_url,
+            room_url.replace('https://', ''),
+            room_url.split('/')[-1],  # Just room name
+        ]
+
+        for pattern in patterns:
+            if pattern in location or pattern in description:
+                return True
+
+        return False
+```
+
+### 2. Database Schema
+
+```sql
+-- Modify room table
+ALTER TABLE room ADD COLUMN ics_url TEXT;  -- encrypted to protect embedded tokens
+ALTER TABLE room ADD COLUMN ics_fetch_interval INTEGER DEFAULT 300;  -- seconds
+ALTER TABLE room ADD COLUMN ics_enabled BOOLEAN DEFAULT FALSE;
+ALTER TABLE room ADD COLUMN ics_last_sync TIMESTAMP;
+ALTER TABLE room ADD COLUMN ics_last_etag TEXT;  -- for caching
+
+-- Calendar events table
+CREATE TABLE calendar_event (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    room_id UUID REFERENCES room(id) ON DELETE CASCADE,
+    external_id TEXT NOT NULL,  -- ICS UID
+    title TEXT,
+    description TEXT,
+    start_time TIMESTAMP NOT NULL,
+    end_time TIMESTAMP NOT NULL,
+    attendees JSONB,
+    location TEXT,
+    ics_raw_data TEXT,  -- Store raw VEVENT for reference
+    last_synced TIMESTAMP DEFAULT NOW(),
+    is_deleted BOOLEAN DEFAULT FALSE,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW(),
+    UNIQUE(room_id, external_id)
+);
+
+-- Index for efficient queries
+CREATE INDEX idx_calendar_event_room_start ON calendar_event(room_id, start_time);
+CREATE INDEX idx_calendar_event_deleted ON calendar_event(is_deleted) WHERE NOT is_deleted;
+```
+
+### 3. Background Tasks
+
+```python
+# reflector/worker/tasks/ics_sync.py
+
+from celery import shared_task
+from datetime import datetime, timedelta
+import hashlib
+
+@shared_task
+def sync_ics_calendars():
+    """Sync all enabled ICS calendars based on their fetch intervals."""
+    rooms = Room.query.filter_by(ics_enabled=True).all()
+
+    for room in rooms:
+        # Check if it's time to sync based on fetch interval
+        if should_sync(room):
+            sync_room_calendar.delay(room.id)
+
+@shared_task
+def sync_room_calendar(room_id: str):
+    """Sync calendar for a specific room."""
+    room = Room.query.get(room_id)
+    if not room or not room.ics_enabled:
+        return
+
+    try:
+        # Fetch ICS file (decrypt URL first)
+        service = ICSFetchService()
+        decrypted_url = decrypt_ics_url(room.ics_url)
+        ics_content = service.fetch_ics(decrypted_url)
+
+        # Check if content changed (using ETag or hash)
+        content_hash = hashlib.md5(ics_content.encode()).hexdigest()
+        if room.ics_last_etag == content_hash:
+            logger.info(f"No changes in ICS for room {room_id}")
+            return
+
+        # Parse and extract events
+        calendar = service.parse_ics(ics_content)
+        events = service.extract_room_events(calendar, room.url)
+
+        # Update database
+        sync_events_to_database(room_id, events)
+
+        # Update sync metadata
+        room.ics_last_sync = datetime.utcnow()
+        room.ics_last_etag = content_hash
+        db.session.commit()
+
+    except Exception as e:
+        logger.error(f"Failed to sync ICS for room {room_id}: {e}")
+
+def should_sync(room) -> bool:
+    """Check if room calendar should be synced."""
+    if not room.ics_last_sync:
+        return True
+
+    time_since_sync = datetime.utcnow() - room.ics_last_sync
+    return time_since_sync.total_seconds() >= room.ics_fetch_interval
+```
+
+### 4. Celery Beat Schedule
+
+```python
+# reflector/worker/celeryconfig.py
+
+from celery.schedules import crontab
+
+beat_schedule = {
+    'sync-ics-calendars': {
+        'task': 'reflector.worker.tasks.ics_sync.sync_ics_calendars',
+        'schedule': 60.0,  # Check every minute which calendars need syncing
+    },
+    'pre-create-meetings': {
+        'task': 'reflector.worker.tasks.ics_sync.pre_create_calendar_meetings',
+        'schedule': 60.0,  # Check every minute for upcoming meetings
+    },
+}
+```
+
+## API Endpoints
+
+### Room ICS Configuration
+
+```python
+# PATCH /v1/rooms/{room_id}
+{
+    "ics_url": "https://calendar.google.com/calendar/ical/.../private-token/basic.ics",
+    "ics_fetch_interval": 300,  # seconds
+    "ics_enabled": true
+    # URL will be encrypted in database to protect embedded tokens
+}
+```
+
+### Manual Sync Trigger
+
+```python
+# POST /v1/rooms/{room_name}/ics/sync
+# Response:
+{
+    "status": "syncing",
+    "last_sync": "2024-01-15T10:30:00Z",
+    "events_found": 5
+}
+```
+
+### ICS Status
+
+```python
+# GET /v1/rooms/{room_name}/ics/status
+# Response:
+{
+    "enabled": true,
+    "last_sync": "2024-01-15T10:30:00Z",
+    "next_sync": "2024-01-15T10:35:00Z",
+    "fetch_interval": 300,
+    "events_count": 12,
+    "upcoming_events": 3
+}
+```
+
+## ICS Parsing Details
+
+### Event Field Mapping
+
+| ICS Field | Database Field | Notes |
+|-----------|---------------|-------|
+| UID | external_id | Unique identifier |
+| SUMMARY | title | Event title |
+| DESCRIPTION | description | Full description |
+| DTSTART | start_time | Convert to UTC |
+| DTEND | end_time | Convert to UTC |
+| LOCATION | location | Check for room URL |
+| ATTENDEE | attendees | Parse into JSON |
+| ORGANIZER | attendees | Add as organizer |
+| STATUS | (internal) | Filter cancelled events |
+
+### Handling Recurring Events
+
+```python
+def expand_recurring_events(event, start_date, end_date):
+    """Expand recurring events into individual occurrences."""
+    from dateutil.rrule import rrulestr
+
+    if 'RRULE' not in event:
+        return [event]
+
+    # Parse recurrence rule
+    rrule_str = event['RRULE'].to_ical().decode()
+    dtstart = event['DTSTART'].dt
+
+    # Generate occurrences
+    rrule = rrulestr(rrule_str, dtstart=dtstart)
+    occurrences = []
+
+    for dt in rrule.between(start_date, end_date):
+        # Clone event with new date
+        occurrence = event.copy()
+        occurrence['DTSTART'].dt = dt
+        if 'DTEND' in event:
+            duration = event['DTEND'].dt - event['DTSTART'].dt
+            occurrence['DTEND'].dt = dt + duration
+
+        # Unique ID for each occurrence
+        occurrence['UID'] = f"{event['UID']}_{dt.isoformat()}"
+        occurrences.append(occurrence)
+
+    return occurrences
+```
+
+### Timezone Handling
+
+```python
+def normalize_datetime(dt):
+    """Convert various datetime formats to UTC."""
+    import pytz
+    from datetime import datetime
+
+    if hasattr(dt, 'dt'):  # icalendar property
+        dt = dt.dt
+
+    if isinstance(dt, datetime):
+        if dt.tzinfo is None:
+            # Assume local timezone if naive
+            dt = pytz.timezone('UTC').localize(dt)
+        else:
+            # Convert to UTC
+            dt = dt.astimezone(pytz.UTC)
+
+    return dt
+```
+
+## Security Considerations
+
+### 1. URL Validation
+
+```python
+def validate_ics_url(url: str) -> bool:
+    """Validate ICS URL for security."""
+    from urllib.parse import urlparse
+
+    parsed = urlparse(url)
+
+    # Must be HTTPS in production
+    if not settings.DEBUG and parsed.scheme != 'https':
+        return False
+
+    # Prevent local file access
+    if parsed.scheme in ('file', 'ftp'):
+        return False
+
+    # Prevent internal network access
+    if is_internal_ip(parsed.hostname):
+        return False
+
+    return True
+```
+
+### 2. Rate Limiting
+
+```python
+# Implement per-room rate limiting
+RATE_LIMITS = {
+    'min_fetch_interval': 60,  # Minimum 1 minute between fetches
+    'max_requests_per_hour': 60,  # Max 60 requests per hour per room
+    'max_file_size': 10 * 1024 * 1024,  # Max 10MB ICS file
+}
+```
+
+### 3. ICS URL Encryption
+
+```python
+from cryptography.fernet import Fernet
+
+class URLEncryption:
+    def __init__(self):
+        self.cipher = Fernet(settings.ENCRYPTION_KEY)
+
+    def encrypt_url(self, url: str) -> str:
+        """Encrypt ICS URL to protect embedded tokens."""
+        return self.cipher.encrypt(url.encode()).decode()
+
+    def decrypt_url(self, encrypted: str) -> str:
+        """Decrypt ICS URL for fetching."""
+        return self.cipher.decrypt(encrypted.encode()).decode()
+
+    def mask_url(self, url: str) -> str:
+        """Mask sensitive parts of URL for display."""
+        from urllib.parse import urlparse, urlunparse
+
+        parsed = urlparse(url)
+        # Keep scheme, host, and path structure but mask tokens
+        if '/private-' in parsed.path:
+            # Google Calendar format
+            parts = parsed.path.split('/private-')
+            masked_path = parts[0] + '/private-***' + parts[1].split('/')[-1]
+        elif 'token=' in url:
+            # Query parameter token
+            masked_path = parsed.path
+            parsed = parsed._replace(query='token=***')
+        else:
+            # Generic masking of path segments that look like tokens
+            import re
+            masked_path = re.sub(r'/[a-zA-Z0-9]{20,}/', '/***/', parsed.path)
+
+        return urlunparse(parsed._replace(path=masked_path))
+```
+
+## Testing Strategy
+
+### 1. Unit Tests
+
+```python
+# tests/test_ics_sync.py
+
+def test_ics_parsing():
+    """Test ICS file parsing."""
+    ics_content = """BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VEVENT
+UID:test-123
+SUMMARY:Team Meeting
+LOCATION:https://reflector.monadical.com/engineering
+DTSTART:20240115T100000Z
+DTEND:20240115T110000Z
+END:VEVENT
+END:VCALENDAR"""
+
+    service = ICSFetchService()
+    calendar = service.parse_ics(ics_content)
+    events = service.extract_room_events(
+        calendar,
+        "https://reflector.monadical.com/engineering"
+    )
+
+    assert len(events) == 1
+    assert events[0]['title'] == 'Team Meeting'
+```
+
+### 2. Integration Tests
+
+```python
+def test_full_sync_flow():
+    """Test complete sync workflow."""
+    # Create room with ICS URL (encrypt URL to protect tokens)
+    encryption = URLEncryption()
+    room = Room(
+        name="test-room",
+        ics_url=encryption.encrypt_url("https://example.com/calendar.ics?token=secret"),
+        ics_enabled=True
+    )
+
+    # Mock ICS fetch
+    with patch('requests.get') as mock_get:
+        mock_get.return_value.text = sample_ics_content
+
+        # Run sync
+        sync_room_calendar(room.id)
+
+        # Verify events created
+        events = CalendarEvent.query.filter_by(room_id=room.id).all()
+        assert len(events) > 0
+```
+
+## Common ICS Provider Configurations
+
+### Google Calendar
+- URL Format: `https://calendar.google.com/calendar/ical/{calendar_id}/private-{token}/basic.ics`
+- Authentication via token embedded in URL
+- Updates every 3-8 hours by default
+
+### Outlook/Office 365
+- URL Format: `https://outlook.office365.com/owa/calendar/{id}/calendar.ics`
+- May include token in URL path or query parameters
+- Real-time updates
+
+### Apple iCloud
+- URL Format: `webcal://p{XX}-caldav.icloud.com/published/2/{token}`
+- Convert webcal:// to https://
+- Token embedded in URL path
+- Public calendars only
+
+### Nextcloud/ownCloud
+- URL Format: `https://cloud.example.com/remote.php/dav/public-calendars/{token}`
+- Token embedded in URL path
+- Configurable update frequency
+
+## Migration from CalDAV
+
+If migrating from an existing CalDAV implementation:
+
+1. **Database Migration**: Rename fields from `caldav_*` to `ics_*`
+2. **URL Conversion**: Most CalDAV servers provide ICS export endpoints
+3. **Authentication**: Convert from username/password to URL-embedded tokens
+4. **Remove Dependencies**: Uninstall caldav library, add icalendar
+5. **Update Background Tasks**: Replace CalDAV sync with ICS fetch
+
+## Performance Optimizations
+
+1. **Caching**: Use ETag/Last-Modified headers to avoid refetching unchanged calendars
+2. **Incremental Sync**: Store last sync timestamp, only process new/modified events
+3. **Batch Processing**: Process multiple room calendars in parallel
+4. **Connection Pooling**: Reuse HTTP connections for multiple requests
+5. **Compression**: Support gzip encoding for large ICS files
+
+## Monitoring and Debugging
+
+### Metrics to Track
+- Sync success/failure rate per room
+- Average sync duration
+- ICS file sizes
+- Number of events processed
+- Failed event matches
+
+### Debug Logging
+```python
+logger.debug(f"Fetching ICS from {room.ics_url}")
+logger.debug(f"ICS content size: {len(ics_content)} bytes")
+logger.debug(f"Found {len(events)} matching events")
+logger.debug(f"Event UIDs: {[e['external_id'] for e in events]}")
+```
+
+### Common Issues
+1. **SSL Certificate Errors**: Add certificate validation options
+2. **Timeout Issues**: Increase timeout for large calendars
+3. **Encoding Problems**: Handle various character encodings
+4. **Timezone Mismatches**: Always convert to UTC
+5. **Memory Issues**: Stream large ICS files instead of loading entirely

PLAN.md

@@ -0,0 +1,337 @@
+# ICS Calendar Integration Plan
+
+## Core Concept
+ICS calendar URLs are attached to rooms (not users) to enable automatic meeting tracking and management through periodic fetching of calendar data.
+
+## Database Schema Updates
+
+### 1. Add ICS configuration to rooms
+- Add `ics_url` field to room table (URL to .ics file, may include auth token)
+- Add `ics_fetch_interval` field to room table (default: 5 minutes, configurable)
+- Add `ics_enabled` boolean field to room table
+- Add `ics_last_sync` timestamp field to room table
+
+### 2. Create calendar_events table
+- `id` - UUID primary key
+- `room_id` - Foreign key to room
+- `external_id` - ICS event UID
+- `title` - Event title
+- `description` - Event description
+- `start_time` - Event start timestamp
+- `end_time` - Event end timestamp
+- `attendees` - JSON field with attendee list and status
+- `location` - Meeting location (should contain room name)
+- `last_synced` - Last sync timestamp
+- `is_deleted` - Boolean flag for soft delete (preserve past events)
+- `ics_raw_data` - TEXT field to store raw VEVENT data for reference
+
+### 3. Update meeting table
+- Add `calendar_event_id` - Foreign key to calendar_events
+- Add `calendar_metadata` - JSON field for additional calendar data
+- Remove unique constraint on room_id + active status (allow multiple active meetings per room)
+
+## Backend Implementation
+
+### 1. ICS Sync Service
+- Create background task that runs based on room's `ics_fetch_interval` (default: 5 minutes)
+- For each room with ICS enabled, fetch the .ics file via HTTP/HTTPS
+- Parse ICS file using icalendar library
+- Extract VEVENT components and filter events looking for room URL (e.g., "https://reflector.monadical.com/max")
+- Store matching events in calendar_events table
+- Mark events as "upcoming" if start_time is within next 30 minutes
+- Pre-create Whereby meetings 1 minute before start (ensures no delay when users join)
+- Soft-delete future events that were removed from calendar (set is_deleted=true)
+- Never delete past events (preserve for historical record)
+- Support authenticated ICS feeds via tokens embedded in URL
+
+### 2. Meeting Management Updates
+- Allow multiple active meetings per room
+- Pre-create meeting record 1 minute before calendar event starts (ensures meeting is ready)
+- Link meeting to calendar_event for metadata
+- Keep meeting active for 15 minutes after last participant leaves (grace period)
+- Don't auto-close if new participant joins within grace period
+
+### 3. API Endpoints
+- `GET /v1/rooms/{room_name}/meetings` - List all active and upcoming meetings for a room
+  - Returns filtered data based on user role (owner vs participant)
+- `GET /v1/rooms/{room_name}/meetings/upcoming` - List upcoming meetings (next 30 min)
+  - Returns filtered data based on user role
+- `POST /v1/rooms/{room_name}/meetings/{meeting_id}/join` - Join specific meeting
+- `PATCH /v1/rooms/{room_id}` - Update room settings (including ICS configuration)
+  - ICS fields only visible/editable by room owner
+- `POST /v1/rooms/{room_name}/ics/sync` - Trigger manual ICS sync
+  - Only accessible by room owner
+- `GET /v1/rooms/{room_name}/ics/status` - Get ICS sync status and last fetch time
+  - Only accessible by room owner
+
+## Frontend Implementation
+
+### 1. Room Settings Page
+- Add ICS configuration section
+- Field for ICS URL (e.g., Google Calendar private URL, Outlook ICS export)
+- Field for fetch interval (dropdown: 1 min, 5 min, 10 min, 30 min, 1 hour)
+- Test connection button (validates ICS file can be fetched and parsed)
+- Manual sync button
+- Show last sync time and next scheduled sync
+
+### 2. Meeting Selection Page (New)
+- Show when accessing `/room/{room_name}`
+- **Host view** (room owner):
+  - Full calendar event details
+  - Meeting title and description
+  - Complete attendee list with RSVP status
+  - Number of current participants
+  - Duration (how long it's been running)
+- **Participant view** (non-owners):
+  - Meeting title only
+  - Date and time
+  - Number of current participants
+  - Duration (how long it's been running)
+  - No attendee list or description (privacy)
+- Display upcoming meetings (visible 30min before):
+  - Show countdown to start
+  - Can click to join early → redirected to waiting page
+  - Waiting page shows countdown until meeting starts
+  - Meeting pre-created by background task (ready when users arrive)
+- Option to create unscheduled meeting (uses existing flow)
+
+### 3. Meeting Room Updates
+- Show calendar metadata in meeting info
+- Display invited attendees vs actual participants
+- Show meeting title from calendar event
+
+## Meeting Lifecycle
+
+### 1. Meeting Creation
+- Automatic: Pre-created 1 minute before calendar event starts (ensures Whereby room is ready)
+- Manual: User creates unscheduled meeting (existing `/rooms/{room_name}/meeting` endpoint)
+- Background task handles pre-creation to avoid delays when users join
+
+### 2. Meeting Join Rules
+- Can join active meetings immediately
+- Can see upcoming meetings 30 minutes before start
+- Can click to join upcoming meetings early → sent to waiting page
+- Waiting page automatically transitions to meeting at scheduled time
+- Unscheduled meetings always joinable (current behavior)
+
+### 3. Meeting Closure Rules
+- All meetings: 15-minute grace period after last participant leaves
+- If participant rejoins within grace period, keep meeting active
+- Calendar meetings: Force close 30 minutes after scheduled end time
+- Unscheduled meetings: Keep active for 8 hours (current behavior)
+
+## ICS Parsing Logic
+
+### 1. Event Matching
+- Parse ICS file using Python icalendar library
+- Iterate through VEVENT components
+- Check LOCATION field for full FQDN URL (e.g., "https://reflector.monadical.com/max")
+- Check DESCRIPTION for room URL or mention
+- Support multiple formats:
+  - Full URL: "https://reflector.monadical.com/max"
+  - With /room path: "https://reflector.monadical.com/room/max"
+  - Partial paths: "room/max", "/max room"
+
+### 2. Attendee Extraction
+- Parse ATTENDEE properties from VEVENT
+- Extract email (MAILTO), name (CN parameter), and RSVP status (PARTSTAT)
+- Store as JSON in calendar_events.attendees
+
+### 3. Sync Strategy
+- Fetch complete ICS file (contains all events)
+- Filter events from (now - 1 hour) to (now + 24 hours) for processing
+- Update existing events if LAST-MODIFIED or SEQUENCE changed
+- Delete future events that no longer exist in ICS (start_time > now)
+- Keep past events for historical record (never delete if start_time < now)
+- Handle recurring events (RRULE) - expand to individual instances
+- Track deleted calendar events to clean up future meetings
+- Cache ICS file hash to detect changes and skip unnecessary processing
+
+## Security Considerations
+
+### 1. ICS URL Security
+- ICS URLs may contain authentication tokens (e.g., Google Calendar private URLs)
+- Store full ICS URLs encrypted using Fernet to protect embedded tokens
+- Validate ICS URLs (must be HTTPS for production)
+- Never expose full ICS URLs in API responses (return masked version)
+- Rate limit ICS fetching to prevent abuse
+
+### 2. Room Access
+- Only room owner can configure ICS URL
+- ICS URL shown as masked version to room owner (hides embedded tokens)
+- ICS settings not visible to other users
+- Meeting list visible to all room participants
+- ICS fetch logs only visible to room owner
+
+### 3. Meeting Privacy
+- Full calendar details visible only to room owner
+- Participants see limited info: title, date/time only
+- Attendee list and description hidden from non-owners
+- Meeting titles visible in room listing to all
+
+## Implementation Phases
+
+### Phase 1: Database and ICS Setup (Week 1) ✅ COMPLETED (2025-08-18)
+1. ✅ Created database migrations for ICS fields and calendar_events table
+   - Added ics_url, ics_fetch_interval, ics_enabled, ics_last_sync, ics_last_etag to room table
+   - Created calendar_event table with ics_uid (instead of external_id) and proper typing
+   - Added calendar_event_id and calendar_metadata (JSONB) to meeting table
+   - Removed server_default from datetime fields for consistency
+2. ✅ Installed icalendar Python library for ICS parsing
+   - Added icalendar>=6.0.0 to dependencies
+   - No encryption needed - ICS URLs are read-only
+3. ✅ Built ICS fetch and sync service
+   - Simple HTTP fetching without unnecessary validation
+   - Proper TypedDict typing for event data structures
+   - Supports any standard ICS format
+   - Event matching on full room URL only
+4. ✅ API endpoints for ICS configuration
+   - Room model updated to support ICS fields via existing PATCH endpoint
+   - POST /v1/rooms/{room_name}/ics/sync - Trigger manual sync (owner only)
+   - GET /v1/rooms/{room_name}/ics/status - Get sync status (owner only)
+   - GET /v1/rooms/{room_name}/meetings - List meetings with privacy controls
+   - GET /v1/rooms/{room_name}/meetings/upcoming - List upcoming meetings
+5. ✅ Celery background tasks for periodic sync
+   - sync_room_ics - Sync individual room calendar
+   - sync_all_ics_calendars - Check all rooms and queue sync based on fetch intervals
+   - pre_create_upcoming_meetings - Pre-create Whereby meetings 1 minute before start
+   - Tasks scheduled in beat schedule (every minute for checking, respects individual intervals)
+6. ✅ Tests written and passing
+   - 6 tests for Room ICS fields
+   - 7 tests for CalendarEvent model
+   - 7 tests for ICS sync service
+   - 11 tests for API endpoints
+   - 6 tests for background tasks
+   - All 31 ICS-related tests passing
+
+### Phase 2: Meeting Management (Week 2) ✅ COMPLETED (2025-08-19)
+1. ✅ Updated meeting lifecycle logic with grace period support
+   - 15-minute grace period after last participant leaves
+   - Automatic reactivation when participants rejoin
+   - Force close calendar meetings 30 minutes after scheduled end
+2. ✅ Support multiple active meetings per room
+   - Removed unique constraint on active meetings
+   - Added get_all_active_for_room() method
+   - Added get_active_by_calendar_event() method
+3. ✅ Implemented grace period logic
+   - Added last_participant_left_at and grace_period_minutes fields
+   - Process meetings task handles grace period checking
+   - Whereby webhooks clear grace period on participant join
+4. ✅ Link meetings to calendar events
+   - Pre-created meetings properly linked via calendar_event_id
+   - Calendar metadata stored with meeting
+   - API endpoints for listing and joining specific meetings
+
+### Phase 3: Frontend Meeting Selection (Week 3)
+1. Build meeting selection page
+2. Show active and upcoming meetings
+3. Implement waiting page for early joiners
+4. Add automatic transition from waiting to meeting
+5. Support unscheduled meeting creation
+
+### Phase 4: Calendar Integration UI (Week 4)
+1. Add ICS settings to room configuration
+2. Display calendar metadata in meetings
+3. Show attendee information
+4. Add sync status indicators
+5. Show fetch interval and next sync time
+
+## Success Metrics
+- Zero merged meetings from consecutive calendar events
+- Successful ICS sync from major providers (Google Calendar, Outlook, Apple Calendar, Nextcloud)
+- Meeting join accuracy: correct meeting 100% of the time
+- Grace period prevents 90% of accidental meeting closures
+- Configurable fetch intervals reduce unnecessary API calls
+
+## Design Decisions
+1. **ICS attached to room, not user** - Prevents duplicate meetings from multiple calendars
+2. **Multiple active meetings per room** - Supported with meeting selection page
+3. **Grace period for rejoining** - 15 minutes after last participant leaves
+4. **Upcoming meeting visibility** - Show 30 minutes before, join only on time
+5. **Calendar data storage** - Attached to meeting record for full context
+6. **No "ad-hoc" meetings** - Use existing meeting creation flow (unscheduled meetings)
+7. **ICS configuration via room PATCH** - Reuse existing room configuration endpoint
+8. **Event deletion handling** - Soft-delete future events, preserve past meetings
+9. **Configurable fetch interval** - Balance between freshness and server load
+10. **ICS over CalDAV** - Simpler implementation, wider compatibility, no complex auth
+
+## Phase 2 Implementation Files
+
+### Database Migrations
+- `/server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py` - Remove unique constraint
+- `/server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py` - Add grace period fields
+
+### Updated Models
+- `/server/reflector/db/meetings.py` - Added grace period fields and new query methods
+
+### Updated Services
+- `/server/reflector/worker/process.py` - Enhanced with grace period logic and multiple meeting support
+
+### Updated API
+- `/server/reflector/views/rooms.py` - Added endpoints for listing active meetings and joining specific meetings
+- `/server/reflector/views/whereby.py` - Clear grace period on participant join
+
+### Tests
+- `/server/tests/test_multiple_active_meetings.py` - Comprehensive tests for Phase 2 features (5 tests)
+
+## Phase 1 Implementation Files Created
+
+### Database Models
+- `/server/reflector/db/rooms.py` - Updated with ICS fields (url, fetch_interval, enabled, last_sync, etag)
+- `/server/reflector/db/calendar_events.py` - New CalendarEvent model with ics_uid and proper typing
+- `/server/reflector/db/meetings.py` - Updated with calendar_event_id and calendar_metadata (JSONB)
+
+### Services
+- `/server/reflector/services/ics_sync.py` - ICS fetching and parsing with TypedDict for proper typing
+
+### API Endpoints
+- `/server/reflector/views/rooms.py` - Added ICS management endpoints with privacy controls
+
+### Background Tasks
+- `/server/reflector/worker/ics_sync.py` - Celery tasks for automatic periodic sync
+- `/server/reflector/worker/app.py` - Updated beat schedule for ICS tasks
+
+### Tests
+- `/server/tests/test_room_ics.py` - Room model ICS fields tests (6 tests)
+- `/server/tests/test_calendar_event.py` - CalendarEvent model tests (7 tests)
+- `/server/tests/test_ics_sync.py` - ICS sync service tests (7 tests)
+- `/server/tests/test_room_ics_api.py` - API endpoint tests (11 tests)
+- `/server/tests/test_ics_background_tasks.py` - Background task tests (6 tests)
+
+### Key Design Decisions
+- No encryption needed - ICS URLs are read-only access
+- Using ics_uid instead of external_id for clarity
+- Proper TypedDict typing for event data structures
+- Removed unnecessary URL validation and webcal handling
+- calendar_metadata in meetings stores flexible calendar data (organizer, recurrence, etc)
+- Background tasks query all rooms directly to avoid filtering issues
+- Sync intervals respected per-room configuration
+
+## Implementation Approach
+
+### ICS Fetching vs CalDAV
+- **ICS Benefits**:
+  - Simpler implementation (HTTP GET vs CalDAV protocol)
+  - Wider compatibility (all calendar apps can export ICS)
+  - No authentication complexity (simple URL with optional token)
+  - Easier debugging (ICS is plain text)
+  - Lower server requirements (no CalDAV library dependencies)
+
+### Supported Calendar Providers
+1. **Google Calendar**: Private ICS URL from calendar settings
+2. **Outlook/Office 365**: ICS export URL from calendar sharing
+3. **Apple Calendar**: Published calendar ICS URL
+4. **Nextcloud**: Public/private calendar ICS export
+5. **Any CalDAV server**: Via ICS export endpoint
+
+### ICS URL Examples
+- Google: `https://calendar.google.com/calendar/ical/{calendar_id}/private-{token}/basic.ics`
+- Outlook: `https://outlook.live.com/owa/calendar/{id}/calendar.ics`
+- Custom: `https://example.com/calendars/room-schedule.ics`
+
+### Fetch Interval Configuration
+- 1 minute: For critical/high-activity rooms
+- 5 minutes (default): Balance of freshness and efficiency
+- 10 minutes: Standard meeting rooms
+- 30 minutes: Low-activity rooms
+- 1 hour: Rarely-used rooms or stable schedules

README.md

@@ -4,8 +4,8 @@
 
 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/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)
+[![Tests](https://github.com/monadical-sas/reflector/actions/workflows/pytests.yml/badge.svg?branch=main&event=push)](https://github.com/monadical-sas/reflector/actions/workflows/pytests.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
 </div>
 
 ## Screenshots
@@ -74,12 +74,12 @@ Note: We currently do not have instructions for Windows users.
 
 ### Frontend
 
-Start with `cd backend`.
+Start with `cd www`.
 
 **Installation**
 
 ```bash
-yarn install
+pnpm install
 cp .env_template .env
 cp config-template.ts config.ts
 ```
@@ -89,7 +89,7 @@ Then, fill in the environment variables in `.env` and the configuration in `conf
 **Run in development mode**
 
 ```bash
-yarn dev
+pnpm dev
 ```
 
 Then (after completing server setup and starting it) open [http://localhost:3000](http://localhost:3000) to view it in the browser.
@@ -99,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
-yarn openapi
+pnpm openapi
 ```
 
 ### Backend

compose.yml

@@ -39,11 +39,12 @@ services:
     image: node:18
     ports:
       - "3000:3000"
-    command: sh -c "yarn install && yarn dev"
+    command: sh -c "corepack enable && pnpm install && pnpm dev"
     restart: unless-stopped
     working_dir: /app
     volumes:
       - ./www:/app/
+      - /app/node_modules
     env_file:
       - ./www/.env.local
 

server/.env_template

@@ -1,21 +0,0 @@
-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***
-
-AUTH_BACKEND=fief
-AUTH_FIEF_URL=https://auth.reflector.media/reflector-local
-AUTH_FIEF_CLIENT_ID=***REMOVED***
-AUTH_FIEF_CLIENT_SECRET=<ask in zulip> <-----------------------------------------------------------------------------------------
-
-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

server/.gitignore

@@ -180,3 +180,4 @@ reflector.sqlite3
 data/
 
 dump.rdb
+

server/README.md

@@ -20,3 +20,23 @@ 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')"
+```

server/env.example

@@ -7,11 +7,9 @@
 ## User authentication
 ## =======================================================
 
-## Using fief (fief.dev)
-AUTH_BACKEND=fief
-AUTH_FIEF_URL=https://auth.reflector.media/reflector-local
-AUTH_FIEF_CLIENT_ID=***REMOVED***
-AUTH_FIEF_CLIENT_SECRET=<ask in zulip>
+## Using jwt/authentik
+AUTH_BACKEND=jwt
+AUTH_JWT_AUDIENCE=
 
 ## =======================================================
 ## Transcription backend
@@ -22,24 +20,24 @@ AUTH_FIEF_CLIENT_SECRET=<ask in zulip>
 
 ## 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=***REMOVED***
+TRANSCRIPT_MODAL_API_KEY=
 
 ## =======================================================
-## Transcription backend
+## Translation 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
@@ -49,28 +47,11 @@ TRANSLATE_URL=https://monadical-sas--reflector-translator-web.modal.run
 ## llm backend implementation
 ## =======================================================
 
-## 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
+## Context size for summary generation (tokens)
+# LLM_MODEL=microsoft/phi-4
+LLM_CONTEXT_WINDOW=16000
+LLM_URL=
+LLM_API_KEY=sk-
 
 ## =======================================================
 ## Diarization
@@ -79,7 +60,9 @@ CACHE_DIR=data
 ## 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
 
 
 ## =======================================================
@@ -88,4 +71,3 @@ DIARIZATION_URL=https://monadical-sas--reflector-diarizer-web.modal.run
 
 ## Sentry DSN configuration
 #SENTRY_DSN=
-

server/gpu/modal_deployments/README.md

@@ -3,8 +3,9 @@
 This repository hold an API for the GPU implementation of the Reflector API service,
 and use [Modal.com](https://modal.com)
 
-- `reflector_llm.py` - LLM API
+- `reflector_diarizer.py` - Diarization API
 - `reflector_transcriber.py` - Transcription API
+- `reflector_translator.py` - Translation API
 
 ## Modal.com deployment
 
@@ -23,16 +24,20 @@ $ modal deploy reflector_llm.py
 └── 🔨 Created web => https://xxxx--reflector-llm-web.modal.run
 ```
 
-Then in your reflector api configuration `.env`, you can set theses keys:
+Then in your reflector api configuration `.env`, you can set these keys:
 
 ```
 TRANSCRIPT_BACKEND=modal
 TRANSCRIPT_URL=https://xxxx--reflector-transcriber-web.modal.run
 TRANSCRIPT_MODAL_API_KEY=REFLECTOR_APIKEY
 
-LLM_BACKEND=modal
-LLM_URL=https://xxxx--reflector-llm-web.modal.run
-LLM_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
 ```
 
 ## API

server/gpu/modal_deployments/reflector_llm.py

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

server/gpu/modal_deployments/reflector_llm_zephyr.py

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

server/gpu/modal_deployments/reflector_vllm_hermes3.py

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

server/migration.load

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

server/migrations/README

@@ -1 +1,3 @@
-Generic single-database configuration.
+Generic single-database configuration.
+
+Both data migrations and schema migrations must be in migrations.

server/migrations/env.py

@@ -1,9 +1,10 @@
 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.

server/migrations/versions/0925da921477_unique_room_names.py

@@ -8,7 +8,6 @@ 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.

server/migrations/versions/0bc0f3ff0111_add_webvtt_field_to_transcript.py

@@ -0,0 +1,25 @@
+"""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")

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
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "0fea6d96b096"

server/migrations/versions/116b2f287eab_add_full_text_search.py

@@ -0,0 +1,46 @@
+"""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")

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
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # 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 ###

server/migrations/versions/20250617140003_add_meeting_consent_table.py

@@ -5,6 +5,7 @@ Revises: f819277e5169
 Create Date: 2025-06-17 14:00:03.000000
 
 """
+
 from typing import Sequence, Union
 
 import sqlalchemy as sa
@@ -19,16 +20,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")

server/migrations/versions/20250618140000_add_audio_deleted_field_to_transcript.py

@@ -5,6 +5,7 @@ Revises: 20250617140003
 Create Date: 2025-06-18 14:00:00.000000
 
 """
+
 from typing import Sequence, Union
 
 import sqlalchemy as sa
@@ -22,4 +23,4 @@ def upgrade() -> None:
 
 
 def downgrade() -> None:
-    op.drop_column("transcript", "audio_deleted")
+    op.drop_column("transcript", "audio_deleted")

server/migrations/versions/2cf0b60a9d34_fix_transcript_duration_type.py

@@ -5,36 +5,40 @@ Revises: ccd68dc784ff
 Create Date: 2025-07-15 16:53:40.397394
 
 """
+
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # 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 ###

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
 
-from alembic import op
 import sqlalchemy as sa
-from sqlalchemy.sql import table, column
+from alembic import op
 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
 

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
 
-from alembic import op
 import sqlalchemy as sa
-from sqlalchemy.sql import table, column
+from alembic import op
 from sqlalchemy import select
-
+from sqlalchemy.sql import column, table
 
 # revision identifiers, used by Alembic.
 revision: str = "4814901632bc"
@@ -24,9 +24,11 @@ def upgrade() -> None:
     # for all the transcripts, calculate the duration from the mp3
     # and update the duration column
     from pathlib import Path
-    from reflector.settings import settings
+
     import av
 
+    from reflector.settings import settings
+
     bind = op.get_bind()
     transcript = table(
         "transcript", column("id", sa.String), column("duration", sa.Float)

server/migrations/versions/543ed284d69a_init.py

@@ -5,14 +5,11 @@ 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

server/migrations/versions/6025e9b2bef2_remove_one_active_meeting_per_room_.py

@@ -0,0 +1,53 @@
+"""remove_one_active_meeting_per_room_constraint
+
+Revision ID: 6025e9b2bef2
+Revises: 9f5c78d352d6
+Create Date: 2025-08-18 18:45:44.418392
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "6025e9b2bef2"
+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:
+    # Remove the unique constraint that prevents multiple active meetings per room
+    # This is needed to support calendar integration with overlapping meetings
+    # Check if index exists before trying to drop it
+    from alembic import context
+
+    if context.get_context().dialect.name == "postgresql":
+        conn = op.get_bind()
+        result = conn.execute(
+            sa.text(
+                "SELECT 1 FROM pg_indexes WHERE indexname = 'idx_one_active_meeting_per_room'"
+            )
+        )
+        if result.fetchone():
+            op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
+    else:
+        # For SQLite, just try to drop it
+        try:
+            op.drop_index("idx_one_active_meeting_per_room", table_name="meeting")
+        except:
+            pass
+
+
+def downgrade() -> None:
+    # Restore the unique constraint
+    op.create_index(
+        "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"),
+    )

server/migrations/versions/62dea3db63a5_add_room_options.py

@@ -8,9 +8,8 @@ Create Date: 2025-06-27 09:04:21.006823
 
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "62dea3db63a5"
@@ -33,7 +32,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("0"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
         ),
         sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
         sa.Column(
@@ -54,12 +53,15 @@ 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("0"), nullable=False
+            "zulip_auto_post",
+            sa.Boolean(),
+            server_default=sa.text("false"),
+            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("0"), nullable=False
+            "is_locked", sa.Boolean(), server_default=sa.text("false"), nullable=False
         ),
         sa.Column("room_mode", sa.String(), server_default="normal", nullable=False),
         sa.Column(

server/migrations/versions/74b2b0236931_add_transcript_source_kind.py

@@ -20,11 +20,14 @@ 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",
-            sa.Enum("ROOM", "LIVE", "FILE", name="sourcekind"),
+            sourcekind_enum,
             nullable=True,
         ),
     )
@@ -43,6 +46,8 @@ 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 ###

server/migrations/versions/764ce6db4388_add_zulip_message_id.py

@@ -5,26 +5,28 @@ Revises: 62dea3db63a5
 Create Date: 2024-09-06 14:02:06.649665
 
 """
+
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # 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 ###

server/migrations/versions/8120ebc75366_populate_webvtt_from_topics.py

@@ -0,0 +1,106 @@
+"""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"))

server/migrations/versions/88d292678ba2_fix_transcript_json_nan_values.py

@@ -9,8 +9,6 @@ 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"
@@ -21,7 +19,7 @@ depends_on: Union[str, Sequence[str], None] = None
 
 def upgrade() -> None:
     import json
-    import re
+
     from sqlalchemy import text
 
     # Get database connection
@@ -58,7 +56,9 @@ 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

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
 
-from alembic import op
 import sqlalchemy as sa
-from sqlalchemy.sql import table, column
+from alembic import op
 from sqlalchemy import select
-
+from sqlalchemy.sql import column, table
 
 # revision identifiers, used by Alembic.
 revision: str = "9920ecfe2735"

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
 
-from alembic import op
 import sqlalchemy as sa
+from alembic import op
 
 # 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, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\');'
+        'REPLACE(events::text, \'"event": "SUMMARY"\', \'"event": "LONG_SUMMARY"\')::json;'
     )
     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, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\');'
+        'REPLACE(events::text, \'"event": "LONG_SUMMARY"\', \'"event": "SUMMARY"\')::json;'
     )
     with op.batch_alter_table("transcript", schema=None) as batch_op:
         batch_op.alter_column("long_summary", nullable=True, new_column_name="summary")

server/migrations/versions/9f5c78d352d6_datetime_timezone.py

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

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("0"),
+            server_default=sa.text("false"),
             nullable=False,
         ),
     )

server/migrations/versions/a9c9c229ee36_transcript_composite_index.py

@@ -9,8 +9,6 @@ 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"

server/migrations/versions/b0e5f7876032_add_meeting_is_active.py

@@ -5,30 +5,37 @@ Revises: 6ea59639f30e
 Create Date: 2025-01-28 10:06:50.446233
 
 """
+
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # 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('1'), 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("true"),
+                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 ###

server/migrations/versions/b3df9681cae9_add_transcript_table.py

@@ -8,9 +8,8 @@ Create Date: 2025-06-27 08:57:16.306940
 
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "b3df9681cae9"

server/migrations/versions/b469348df210_remove_viewer_room_url.py

@@ -8,9 +8,8 @@ Create Date: 2024-10-11 13:45:28.914902
 
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "b469348df210"

server/migrations/versions/b7df9609542c_add_unique_constraint_one_active_.py

@@ -0,0 +1,35 @@
+"""add_unique_constraint_one_active_meeting_per_room
+
+Revision ID: b7df9609542c
+Revises: d7fbb74b673b
+Create Date: 2025-07-25 16:27:06.959868
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+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
+
+
+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"],
+        unique=True,
+        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")

server/migrations/versions/b9348748bbbc_reviewed.py

@@ -5,25 +5,31 @@ Revises: 125031f7cb78
 Create Date: 2023-12-13 15:37:51.303970
 
 """
+
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
+from alembic import op
 
 # 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('0'), nullable=False))
+    op.add_column(
+        "transcript",
+        sa.Column(
+            "reviewed", sa.Boolean(), server_default=sa.text("false"), 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 ###

server/migrations/versions/ccd68dc784ff_add_performance_indexes.py

@@ -9,8 +9,6 @@ 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"

server/migrations/versions/d3ff3a39297f_add_recordings.py

@@ -8,9 +8,8 @@ Create Date: 2025-06-27 09:27:25.302152
 
 from typing import Sequence, Union
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "d3ff3a39297f"

server/migrations/versions/d4a1c446458c_add_grace_period_fields_to_meeting.py

@@ -0,0 +1,34 @@
+"""add_grace_period_fields_to_meeting
+
+Revision ID: d4a1c446458c
+Revises: 6025e9b2bef2
+Create Date: 2025-08-18 18:50:37.768052
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "d4a1c446458c"
+down_revision: Union[str, None] = "6025e9b2bef2"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Add fields to track when participants left for grace period logic
+    op.add_column(
+        "meeting", sa.Column("last_participant_left_at", sa.DateTime(timezone=True))
+    )
+    op.add_column(
+        "meeting",
+        sa.Column("grace_period_minutes", sa.Integer, server_default=sa.text("15")),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("meeting", "grace_period_minutes")
+    op.drop_column("meeting", "last_participant_left_at")

server/migrations/versions/d7fbb74b673b_add_room_id_to_transcript.py

@@ -0,0 +1,59 @@
+"""Add room_id to transcript
+
+Revision ID: d7fbb74b673b
+Revises: a9c9c229ee36
+Create Date: 2025-07-17 12:00:00.000000
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "d7fbb74b673b"
+down_revision: Union[str, None] = "a9c9c229ee36"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Add room_id column to transcript table
+    op.add_column("transcript", sa.Column("room_id", sa.String(), nullable=True))
+
+    # Add index for room_id for better query performance
+    op.create_index("idx_transcript_room_id", "transcript", ["room_id"])
+
+    # Populate room_id for existing ROOM-type transcripts
+    # This joins through recording -> meeting -> room to get the room_id
+    op.execute("""
+        UPDATE transcript AS t
+        SET room_id = r.id
+        FROM recording rec
+        JOIN meeting m ON rec.meeting_id = m.id
+        JOIN room r ON m.room_id = r.id
+        WHERE t.recording_id = rec.id
+        AND t.source_kind = 'room'
+        AND t.room_id IS NULL
+    """)
+
+    # Fix missing meeting_id for ROOM-type transcripts
+    # The meeting_id field exists but was never populated
+    op.execute("""
+        UPDATE transcript AS t
+        SET meeting_id = rec.meeting_id
+        FROM recording rec
+        WHERE t.recording_id = rec.id
+        AND t.source_kind = 'room'
+        AND t.meeting_id IS NULL
+        AND rec.meeting_id IS NOT NULL
+    """)
+
+
+def downgrade() -> None:
+    # Drop the index first
+    op.drop_index("idx_transcript_room_id", "transcript")
+
+    # Drop the room_id column
+    op.drop_column("transcript", "room_id")

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
 
-from alembic import op
 import sqlalchemy as sa
-
+from alembic import op
 
 # revision identifiers, used by Alembic.
 revision: str = "f819277e5169"

server/pyproject.toml

@@ -22,7 +22,6 @@ dependencies = [
     "fastapi-pagination>=0.12.6",
     "databases[aiosqlite, asyncpg]>=0.7.0",
     "sqlalchemy<1.5",
-    "fief-client[fastapi]>=0.17.0",
     "alembic>=1.11.3",
     "nltk>=3.8.1",
     "prometheus-fastapi-instrumentator>=6.1.0",
@@ -35,10 +34,14 @@ dependencies = [
     "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",
+    "icalendar>=6.0.0",
 ]
 
 [dependency-groups]
@@ -55,6 +58,8 @@ tests = [
     "httpx-ws>=0.4.1",
     "pytest-httpx>=0.23.1",
     "pytest-celery>=0.0.0",
+    "pytest-docker>=3.2.3",
+    "asgi-lifespan>=2.1.0",
 ]
 aws = ["aioboto3>=11.2.0"]
 evaluation = [
@@ -82,10 +87,25 @@ 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"
 
+[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"]

server/reflector/app.py

@@ -1,12 +1,13 @@
 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

server/reflector/auth/__init__.py

@@ -1,7 +1,8 @@
-from reflector.settings import settings
-from reflector.logger import logger
 import importlib
 
+from reflector.logger import logger
+from reflector.settings import settings
+
 logger.info(f"User authentication using {settings.AUTH_BACKEND}")
 module_name = f"reflector.auth.auth_{settings.AUTH_BACKEND}"
 auth_module = importlib.import_module(module_name)

server/reflector/auth/auth_fief.py

@@ -1,25 +0,0 @@
-from fastapi.security import OAuth2AuthorizationCodeBearer
-from fief_client import FiefAccessTokenInfo, FiefAsync, FiefUserInfo
-from fief_client.integrations.fastapi import FiefAuth
-from reflector.settings import settings
-
-fief = FiefAsync(
-    settings.AUTH_FIEF_URL,
-    settings.AUTH_FIEF_CLIENT_ID,
-    settings.AUTH_FIEF_CLIENT_SECRET,
-)
-
-scheme = OAuth2AuthorizationCodeBearer(
-    f"{settings.AUTH_FIEF_URL}/authorize",
-    f"{settings.AUTH_FIEF_URL}/api/token",
-    scopes={"openid": "openid", "offline_access": "offline_access"},
-    auto_error=False,
-)
-
-auth = FiefAuth(fief, scheme)
-
-UserInfo = FiefUserInfo
-AccessTokenInfo = FiefAccessTokenInfo
-authenticated = auth.authenticated()
-current_user = auth.current_user()
-current_user_optional = auth.current_user(optional=True)

server/reflector/auth/auth_jwt.py

@@ -4,6 +4,7 @@ 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
 

server/reflector/auth/auth_none.py

@@ -1,7 +1,8 @@
-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)
 

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)

server/reflector/db/__init__.py

@@ -1,28 +1,48 @@
+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.calendar_events  # noqa
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
 import reflector.db.rooms  # noqa
 import reflector.db.transcripts  # noqa
 
 kwargs = {}
-if "sqlite" in settings.DATABASE_URL:
-    kwargs["connect_args"] = {"check_same_thread": False}
+if "postgres" not in settings.DATABASE_URL:
+    raise Exception("Only postgres database is supported in reflector")
 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()

server/reflector/db/calendar_events.py

@@ -0,0 +1,193 @@
+from datetime import datetime, timezone
+from typing import Any
+
+import sqlalchemy as sa
+from pydantic import BaseModel, Field
+from sqlalchemy.dialects.postgresql import JSONB
+
+from reflector.db import get_database, metadata
+from reflector.utils import generate_uuid4
+
+calendar_events = sa.Table(
+    "calendar_event",
+    metadata,
+    sa.Column("id", sa.String, primary_key=True),
+    sa.Column(
+        "room_id",
+        sa.String,
+        sa.ForeignKey("room.id", ondelete="CASCADE"),
+        nullable=False,
+    ),
+    sa.Column("ics_uid", sa.Text, nullable=False),
+    sa.Column("title", sa.Text),
+    sa.Column("description", sa.Text),
+    sa.Column("start_time", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("end_time", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("attendees", JSONB),
+    sa.Column("location", sa.Text),
+    sa.Column("ics_raw_data", sa.Text),
+    sa.Column("last_synced", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("is_deleted", sa.Boolean, nullable=False, server_default=sa.false()),
+    sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+    sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+    sa.UniqueConstraint("room_id", "ics_uid", name="uq_room_calendar_event"),
+    sa.Index("idx_calendar_event_room_start", "room_id", "start_time"),
+    sa.Index(
+        "idx_calendar_event_deleted",
+        "is_deleted",
+        postgresql_where=sa.text("NOT is_deleted"),
+    ),
+)
+
+
+class CalendarEvent(BaseModel):
+    id: str = Field(default_factory=generate_uuid4)
+    room_id: str
+    ics_uid: str
+    title: str | None = None
+    description: str | None = None
+    start_time: datetime
+    end_time: datetime
+    attendees: list[dict[str, Any]] | None = None
+    location: str | None = None
+    ics_raw_data: str | None = None
+    last_synced: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    is_deleted: bool = False
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class CalendarEventController:
+    async def get_by_room(
+        self,
+        room_id: str,
+        include_deleted: bool = False,
+        start_after: datetime | None = None,
+        end_before: datetime | None = None,
+    ) -> list[CalendarEvent]:
+        """Get calendar events for a room."""
+        query = calendar_events.select().where(calendar_events.c.room_id == room_id)
+
+        if not include_deleted:
+            query = query.where(calendar_events.c.is_deleted == False)
+
+        if start_after:
+            query = query.where(calendar_events.c.start_time >= start_after)
+
+        if end_before:
+            query = query.where(calendar_events.c.end_time <= end_before)
+
+        query = query.order_by(calendar_events.c.start_time.asc())
+
+        results = await get_database().fetch_all(query)
+        return [CalendarEvent(**result) for result in results]
+
+    async def get_upcoming(
+        self, room_id: str, minutes_ahead: int = 30
+    ) -> list[CalendarEvent]:
+        """Get upcoming events for a room within the specified minutes."""
+        now = datetime.now(timezone.utc)
+        future_time = now + timedelta(minutes=minutes_ahead)
+
+        query = (
+            calendar_events.select()
+            .where(
+                sa.and_(
+                    calendar_events.c.room_id == room_id,
+                    calendar_events.c.is_deleted == False,
+                    calendar_events.c.start_time >= now,
+                    calendar_events.c.start_time <= future_time,
+                )
+            )
+            .order_by(calendar_events.c.start_time.asc())
+        )
+
+        results = await get_database().fetch_all(query)
+        return [CalendarEvent(**result) for result in results]
+
+    async def get_by_ics_uid(self, room_id: str, ics_uid: str) -> CalendarEvent | None:
+        """Get a calendar event by its ICS UID."""
+        query = calendar_events.select().where(
+            sa.and_(
+                calendar_events.c.room_id == room_id,
+                calendar_events.c.ics_uid == ics_uid,
+            )
+        )
+        result = await get_database().fetch_one(query)
+        return CalendarEvent(**result) if result else None
+
+    async def upsert(self, event: CalendarEvent) -> CalendarEvent:
+        """Create or update a calendar event."""
+        existing = await self.get_by_ics_uid(event.room_id, event.ics_uid)
+
+        if existing:
+            # Update existing event
+            event.id = existing.id
+            event.created_at = existing.created_at
+            event.updated_at = datetime.now(timezone.utc)
+
+            query = (
+                calendar_events.update()
+                .where(calendar_events.c.id == existing.id)
+                .values(**event.model_dump())
+            )
+        else:
+            # Insert new event
+            query = calendar_events.insert().values(**event.model_dump())
+
+        await get_database().execute(query)
+        return event
+
+    async def soft_delete_missing(
+        self, room_id: str, current_ics_uids: list[str]
+    ) -> int:
+        """Soft delete future events that are no longer in the calendar."""
+        now = datetime.now(timezone.utc)
+
+        # First, get the IDs of events to delete
+        select_query = calendar_events.select().where(
+            sa.and_(
+                calendar_events.c.room_id == room_id,
+                calendar_events.c.start_time > now,
+                calendar_events.c.is_deleted == False,
+                calendar_events.c.ics_uid.notin_(current_ics_uids)
+                if current_ics_uids
+                else True,
+            )
+        )
+
+        to_delete = await get_database().fetch_all(select_query)
+        delete_count = len(to_delete)
+
+        if delete_count > 0:
+            # Now update them
+            update_query = (
+                calendar_events.update()
+                .where(
+                    sa.and_(
+                        calendar_events.c.room_id == room_id,
+                        calendar_events.c.start_time > now,
+                        calendar_events.c.is_deleted == False,
+                        calendar_events.c.ics_uid.notin_(current_ics_uids)
+                        if current_ics_uids
+                        else True,
+                    )
+                )
+                .values(is_deleted=True, updated_at=now)
+            )
+
+            await get_database().execute(update_query)
+
+        return delete_count
+
+    async def delete_by_room(self, room_id: str) -> int:
+        """Hard delete all events for a room (used when room is deleted)."""
+        query = calendar_events.delete().where(calendar_events.c.room_id == room_id)
+        result = await get_database().execute(query)
+        return result.rowcount
+
+
+# Add missing import
+from datetime import timedelta
+
+calendar_events_controller = CalendarEventController()

server/reflector/db/meetings.py

@@ -1,10 +1,12 @@
 from datetime import datetime
-from typing import Literal
+from typing import Any, Literal
 
 import sqlalchemy as sa
 from fastapi import HTTPException
 from pydantic import BaseModel, Field
-from reflector.db import database, metadata
+from sqlalchemy.dialects.postgresql import JSONB
+
+from reflector.db import get_database, metadata
 from reflector.db.rooms import Room
 from reflector.utils import generate_uuid4
 
@@ -15,8 +17,8 @@ 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),
-    sa.Column("end_date", sa.DateTime),
+    sa.Column("start_date", sa.DateTime(timezone=True)),
+    sa.Column("end_date", sa.DateTime(timezone=True)),
     sa.Column("user_id", sa.String),
     sa.Column("room_id", sa.String),
     sa.Column("is_locked", sa.Boolean, nullable=False, server_default=sa.false()),
@@ -40,7 +42,16 @@ meetings = sa.Table(
         nullable=False,
         server_default=sa.true(),
     ),
+    sa.Column(
+        "calendar_event_id",
+        sa.String,
+        sa.ForeignKey("calendar_event.id", ondelete="SET NULL"),
+    ),
+    sa.Column("calendar_metadata", JSONB),
+    sa.Column("last_participant_left_at", sa.DateTime(timezone=True)),
+    sa.Column("grace_period_minutes", sa.Integer, server_default=sa.text("15")),
     sa.Index("idx_meeting_room_id", "room_id"),
+    sa.Index("idx_meeting_calendar_event", "calendar_event_id"),
 )
 
 meeting_consent = sa.Table(
@@ -50,7 +61,7 @@ meeting_consent = sa.Table(
     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, nullable=False),
+    sa.Column("consent_timestamp", sa.DateTime(timezone=True), nullable=False),
 )
 
 
@@ -78,6 +89,11 @@ class Meeting(BaseModel):
         "none", "prompt", "automatic", "automatic-2nd-participant"
     ] = "automatic-2nd-participant"
     num_clients: int = 0
+    is_active: bool = True
+    calendar_event_id: str | None = None
+    calendar_metadata: dict[str, Any] | None = None
+    last_participant_left_at: datetime | None = None
+    grace_period_minutes: int = 15
 
 
 class MeetingController:
@@ -91,6 +107,8 @@ class MeetingController:
         end_date: datetime,
         user_id: str,
         room: Room,
+        calendar_event_id: str | None = None,
+        calendar_metadata: dict[str, Any] | None = None,
     ):
         """
         Create a new meeting
@@ -108,9 +126,11 @@ class MeetingController:
             room_mode=room.room_mode,
             recording_type=room.recording_type,
             recording_trigger=room.recording_trigger,
+            calendar_event_id=calendar_event_id,
+            calendar_metadata=calendar_metadata,
         )
         query = meetings.insert().values(**meeting.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return meeting
 
     async def get_all_active(self) -> list[Meeting]:
@@ -118,7 +138,7 @@ class MeetingController:
         Get active meetings.
         """
         query = meetings.select().where(meetings.c.is_active)
-        return await database.fetch_all(query)
+        return await get_database().fetch_all(query)
 
     async def get_by_room_name(
         self,
@@ -128,7 +148,7 @@ class MeetingController:
         Get a meeting by room name.
         """
         query = meetings.select().where(meetings.c.room_name == room_name)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
 
@@ -137,6 +157,7 @@ class MeetingController:
     async def get_active(self, room: Room, current_time: datetime) -> Meeting:
         """
         Get latest active meeting for a room.
+        For backward compatibility, returns the most recent active meeting.
         """
         end_date = getattr(meetings.c, "end_date")
         query = (
@@ -150,18 +171,59 @@ class MeetingController:
             )
             .order_by(end_date.desc())
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
 
         return Meeting(**result)
 
+    async def get_all_active_for_room(
+        self, room: Room, current_time: datetime
+    ) -> list[Meeting]:
+        """
+        Get all active meetings for a room.
+        This supports multiple concurrent meetings per room.
+        """
+        end_date = getattr(meetings.c, "end_date")
+        query = (
+            meetings.select()
+            .where(
+                sa.and_(
+                    meetings.c.room_id == room.id,
+                    meetings.c.end_date > current_time,
+                    meetings.c.is_active,
+                )
+            )
+            .order_by(end_date.desc())
+        )
+        results = await get_database().fetch_all(query)
+        return [Meeting(**result) for result in results]
+
+    async def get_active_by_calendar_event(
+        self, room: Room, calendar_event_id: str, current_time: datetime
+    ) -> Meeting | None:
+        """
+        Get active meeting for a specific calendar event.
+        """
+        query = meetings.select().where(
+            sa.and_(
+                meetings.c.room_id == room.id,
+                meetings.c.calendar_event_id == calendar_event_id,
+                meetings.c.end_date > current_time,
+                meetings.c.is_active,
+            )
+        )
+        result = await get_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 database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Meeting(**result)
@@ -173,7 +235,7 @@ class MeetingController:
         If not found, it will raise a 404 error.
         """
         query = meetings.select().where(meetings.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             raise HTTPException(status_code=404, detail="Meeting not found")
 
@@ -183,9 +245,18 @@ class MeetingController:
 
         return meeting
 
+    async def get_by_calendar_event(self, calendar_event_id: str) -> Meeting | None:
+        query = meetings.select().where(
+            meetings.c.calendar_event_id == calendar_event_id
+        )
+        result = await get_database().fetch_one(query)
+        if not result:
+            return None
+        return Meeting(**result)
+
     async def update_meeting(self, meeting_id: str, **kwargs):
         query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
-        await database.execute(query)
+        await get_database().execute(query)
 
 
 class MeetingConsentController:
@@ -193,7 +264,7 @@ class MeetingConsentController:
         query = meeting_consent.select().where(
             meeting_consent.c.meeting_id == meeting_id
         )
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return [MeetingConsent(**result) for result in results]
 
     async def get_by_meeting_and_user(
@@ -204,7 +275,7 @@ class MeetingConsentController:
             meeting_consent.c.meeting_id == meeting_id,
             meeting_consent.c.user_id == user_id,
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if result is None:
             return None
         return MeetingConsent(**result) if result else None
@@ -226,14 +297,14 @@ class MeetingConsentController:
                         consent_timestamp=consent.consent_timestamp,
                     )
                 )
-                await database.execute(query)
+                await get_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 database.execute(query)
+        await get_database().execute(query)
         return consent
 
     async def has_any_denial(self, meeting_id: str) -> bool:
@@ -242,7 +313,7 @@ class MeetingConsentController:
             meeting_consent.c.meeting_id == meeting_id,
             meeting_consent.c.consent_given.is_(False),
         )
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         return result is not None
 
 

server/reflector/db/migrate_user.py

@@ -1,56 +0,0 @@
-from reflector.db import database
-from reflector.db.meetings import meetings
-from reflector.db.rooms import rooms
-from reflector.db.transcripts import transcripts
-
-users_to_migrate = [
-    ["123@lifex.pink", "63b727f5-485d-449f-b528-563d779b11ef", None],
-    ["ana@monadical.com", "1bae2e4d-5c04-49c2-932f-a86266a6ca13", None],
-    ["cspencer@sprocket.org", "614ed0be-392e-488c-bd19-6a9730fd0e9e", None],
-    ["daniel.f.lopez.j@gmail.com", "ca9561bd-c989-4a1e-8877-7081cf62ae7f", None],
-    ["jenalee@monadical.com", "c7c1e79e-b068-4b28-a9f4-29d98b1697ed", None],
-    ["jennifer@rootandseed.com", "f5321727-7546-4b2b-b69d-095a931ef0c4", None],
-    ["jose@monadical.com", "221f079c-7ce0-4677-90b7-0359b6315e27", None],
-    ["labenclayton@gmail.com", "40078cd0-543c-40e4-9c2e-5ce57a686428", None],
-    ["mathieu@monadical.com", "c7a36151-851e-4afa-9fab-aaca834bfd30", None],
-    ["michal.flak.96@gmail.com", "3096eb5e-b590-41fc-a0d1-d152c1895402", None],
-    ["sara@monadical.com", "31ab0cfe-5d2c-4c7a-84de-a29494714c99", None],
-    ["sara@monadical.com", "b871e5f0-754e-447f-9c3d-19f629f0082b", None],
-    ["sebastian@monadical.com", "f024f9d0-15d0-480f-8529-43959fc8b639", None],
-    ["sergey@monadical.com", "5c4798eb-b9ab-4721-a540-bd96fc434156", None],
-    ["sergey@monadical.com", "9dd8a6b4-247e-48fe-b1fb-4c84dd3c01bc", None],
-    ["transient.tran@gmail.com", "617ba2d3-09b6-4b1f-a435-a7f41c3ce060", None],
-]
-
-
-async def migrate_user(email, user_id):
-    # if the email match the email in the users_to_migrate list
-    # reassign all transcripts/rooms/meetings to the new user_id
-
-    user_ids = [user[1] for user in users_to_migrate if user[0] == email]
-    if not user_ids:
-        return
-
-    # do not migrate back
-    if user_id in user_ids:
-        return
-
-    for old_user_id in user_ids:
-        query = (
-            transcripts.update()
-            .where(transcripts.c.user_id == old_user_id)
-            .values(user_id=user_id)
-        )
-        await database.execute(query)
-
-        query = (
-            rooms.update().where(rooms.c.user_id == old_user_id).values(user_id=user_id)
-        )
-        await database.execute(query)
-
-        query = (
-            meetings.update()
-            .where(meetings.c.user_id == old_user_id)
-            .values(user_id=user_id)
-        )
-        await database.execute(query)

server/reflector/db/recordings.py

@@ -3,7 +3,8 @@ from typing import Literal
 
 import sqlalchemy as sa
 from pydantic import BaseModel, Field
-from reflector.db import database, metadata
+
+from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
 
 recordings = sa.Table(
@@ -12,7 +13,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, nullable=False),
+    sa.Column("recorded_at", sa.DateTime(timezone=True), nullable=False),
     sa.Column(
         "status",
         sa.String,
@@ -36,12 +37,12 @@ class Recording(BaseModel):
 class RecordingController:
     async def create(self, recording: Recording):
         query = recordings.insert().values(**recording.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return recording
 
     async def get_by_id(self, id: str) -> Recording:
         query = recordings.select().where(recordings.c.id == id)
-        result = await database.fetch_one(query)
+        result = await get_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:
@@ -49,8 +50,12 @@ class RecordingController:
             recordings.c.bucket_name == bucket_name,
             recordings.c.object_key == object_key,
         )
-        result = await database.fetch_one(query)
+        result = await get_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()

server/reflector/db/rooms.py

@@ -1,21 +1,22 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from sqlite3 import IntegrityError
 from typing import Literal
 
 import sqlalchemy
 from fastapi import HTTPException
 from pydantic import BaseModel, Field
-from reflector.db import database, metadata
-from reflector.utils import generate_uuid4
 from sqlalchemy.sql import false, or_
 
+from reflector.db import get_database, metadata
+from reflector.utils import generate_uuid4
+
 rooms = sqlalchemy.Table(
     "room",
     metadata,
     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, nullable=False),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True), nullable=False),
     sqlalchemy.Column(
         "zulip_auto_post", sqlalchemy.Boolean, nullable=False, server_default=false()
     ),
@@ -39,7 +40,15 @@ rooms = sqlalchemy.Table(
     sqlalchemy.Column(
         "is_shared", sqlalchemy.Boolean, nullable=False, server_default=false()
     ),
+    sqlalchemy.Column("ics_url", sqlalchemy.Text),
+    sqlalchemy.Column("ics_fetch_interval", sqlalchemy.Integer, server_default="300"),
+    sqlalchemy.Column(
+        "ics_enabled", sqlalchemy.Boolean, nullable=False, server_default=false()
+    ),
+    sqlalchemy.Column("ics_last_sync", sqlalchemy.DateTime(timezone=True)),
+    sqlalchemy.Column("ics_last_etag", sqlalchemy.Text),
     sqlalchemy.Index("idx_room_is_shared", "is_shared"),
+    sqlalchemy.Index("idx_room_ics_enabled", "ics_enabled"),
 )
 
 
@@ -47,7 +56,7 @@ class Room(BaseModel):
     id: str = Field(default_factory=generate_uuid4)
     name: str
     user_id: str
-    created_at: datetime = Field(default_factory=datetime.utcnow)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     zulip_auto_post: bool = False
     zulip_stream: str = ""
     zulip_topic: str = ""
@@ -58,6 +67,11 @@ class Room(BaseModel):
         "none", "prompt", "automatic", "automatic-2nd-participant"
     ] = "automatic-2nd-participant"
     is_shared: bool = False
+    ics_url: str | None = None
+    ics_fetch_interval: int = 300
+    ics_enabled: bool = False
+    ics_last_sync: datetime | None = None
+    ics_last_etag: str | None = None
 
 
 class RoomController:
@@ -91,7 +105,7 @@ class RoomController:
         if return_query:
             return query
 
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return results
 
     async def add(
@@ -106,6 +120,9 @@ class RoomController:
         recording_type: str,
         recording_trigger: str,
         is_shared: bool,
+        ics_url: str | None = None,
+        ics_fetch_interval: int = 300,
+        ics_enabled: bool = False,
     ):
         """
         Add a new room
@@ -121,10 +138,13 @@ class RoomController:
             recording_type=recording_type,
             recording_trigger=recording_trigger,
             is_shared=is_shared,
+            ics_url=ics_url,
+            ics_fetch_interval=ics_fetch_interval,
+            ics_enabled=ics_enabled,
         )
         query = rooms.insert().values(**room.model_dump())
         try:
-            await database.execute(query)
+            await get_database().execute(query)
         except IntegrityError:
             raise HTTPException(status_code=400, detail="Room name is not unique")
         return room
@@ -135,7 +155,7 @@ class RoomController:
         """
         query = rooms.update().where(rooms.c.id == room.id).values(**values)
         try:
-            await database.execute(query)
+            await get_database().execute(query)
         except IntegrityError:
             raise HTTPException(status_code=400, detail="Room name is not unique")
 
@@ -150,7 +170,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 database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Room(**result)
@@ -162,7 +182,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 database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Room(**result)
@@ -174,7 +194,7 @@ class RoomController:
         If not found, it will raise a 404 error.
         """
         query = rooms.select().where(rooms.c.id == meeting_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             raise HTTPException(status_code=404, detail="Room not found")
 
@@ -196,7 +216,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 database.execute(query)
+        await get_database().execute(query)
 
 
 rooms_controller = RoomController()

server/reflector/db/search.py

@@ -0,0 +1,231 @@
+"""Search functionality for transcripts and other entities."""
+
+from datetime import datetime
+from io import StringIO
+from typing import Annotated, Any, Dict
+
+import sqlalchemy
+import webvtt
+from pydantic import BaseModel, Field, constr, field_serializer
+
+from reflector.db import get_database
+from reflector.db.transcripts import SourceKind, transcripts
+from reflector.db.utils import is_postgresql
+from reflector.logger import logger
+
+DEFAULT_SEARCH_LIMIT = 20
+SNIPPET_CONTEXT_LENGTH = 50  # Characters before/after match to include
+DEFAULT_SNIPPET_MAX_LENGTH = 150
+DEFAULT_MAX_SNIPPETS = 3
+
+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")]
+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")
+]
+
+
+class SearchParameters(BaseModel):
+    """Validated search parameters for full-text search."""
+
+    query_text: SearchQuery
+    limit: SearchLimit = DEFAULT_SEARCH_LIMIT
+    offset: SearchOffset = 0
+    user_id: str | None = None
+    room_id: str | 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
+    created_at: datetime
+    status: str = Field(..., min_length=1)
+    rank: float = Field(..., ge=0, le=1)
+    duration: float | None = Field(..., ge=0, description="Duration in seconds")
+    search_snippets: list[str] = Field(
+        description="Text snippets around search matches"
+    )
+
+    @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 SearchController:
+    """Controller for search operations across different entities."""
+
+    @staticmethod
+    def _extract_webvtt_text(webvtt_content: str) -> str:
+        """Extract plain text from WebVTT content using webvtt library."""
+        if not webvtt_content:
+            return ""
+
+        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, UnicodeDecodeError, ValueError) as e:
+            logger.warning(f"Failed to parse WebVTT content: {e}", exc_info=e)
+            return ""
+        except AttributeError as e:
+            logger.warning(f"WebVTT parsing error - unexpected format: {e}", exc_info=e)
+            return ""
+
+    @staticmethod
+    def _generate_snippets(
+        text: str,
+        q: SearchQuery,
+        max_length: int = DEFAULT_SNIPPET_MAX_LENGTH,
+        max_snippets: int = DEFAULT_MAX_SNIPPETS,
+    ) -> list[str]:
+        """Generate multiple snippets around all occurrences of search term."""
+        if not text or not q:
+            return []
+
+        snippets = []
+        lower_text = text.lower()
+        search_lower = q.lower()
+
+        last_snippet_end = 0
+        start_pos = 0
+
+        while len(snippets) < max_snippets:
+            match_pos = lower_text.find(search_lower, start_pos)
+
+            if match_pos == -1:
+                if not snippets and search_lower.split():
+                    first_word = search_lower.split()[0]
+                    match_pos = lower_text.find(first_word, start_pos)
+                    if match_pos == -1:
+                        break
+                else:
+                    break
+
+            snippet_start = max(0, match_pos - SNIPPET_CONTEXT_LENGTH)
+            snippet_end = min(
+                len(text), match_pos + max_length - SNIPPET_CONTEXT_LENGTH
+            )
+
+            if snippet_start < last_snippet_end:
+                start_pos = match_pos + len(search_lower)
+                continue
+
+            snippet = text[snippet_start:snippet_end]
+
+            if snippet_start > 0:
+                snippet = "..." + snippet
+            if snippet_end < len(text):
+                snippet = snippet + "..."
+
+            snippet = snippet.strip()
+
+            if snippet:
+                snippets.append(snippet)
+                last_snippet_end = snippet_end
+
+            start_pos = match_pos + len(search_lower)
+            if start_pos >= len(text):
+                break
+
+        return snippets
+
+    @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
+
+        search_query = sqlalchemy.func.websearch_to_tsquery(
+            "english", params.query_text
+        )
+
+        base_query = sqlalchemy.select(
+            [
+                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,
+                sqlalchemy.func.ts_rank(
+                    transcripts.c.search_vector_en,
+                    search_query,
+                    32,  # normalization flag: rank/(rank+1) for 0-1 range
+                ).label("rank"),
+            ]
+        ).where(transcripts.c.search_vector_en.op("@@")(search_query))
+
+        if params.user_id:
+            base_query = base_query.where(transcripts.c.user_id == params.user_id)
+        if params.room_id:
+            base_query = base_query.where(transcripts.c.room_id == params.room_id)
+
+        query = (
+            base_query.order_by(sqlalchemy.desc(sqlalchemy.text("rank")))
+            .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) -> SearchResult:
+            r_dict: Dict[str, Any] = dict(r)
+            webvtt: str | None = r_dict.pop("webvtt", None)
+            db_result = SearchResultDB.model_validate(r_dict)
+
+            snippets = []
+            if webvtt:
+                plain_text = cls._extract_webvtt_text(webvtt)
+                snippets = cls._generate_snippets(plain_text, params.query_text)
+
+            return SearchResult(**db_result.model_dump(), search_snippets=snippets)
+
+        results = [_process_result(r) for r in rs]
+        return results, total
+
+
+search_controller = SearchController()

server/reflector/db/transcripts.py

@@ -3,20 +3,27 @@ import json
 import os
 import shutil
 from contextlib import asynccontextmanager
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, 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 reflector.db import database, metadata
+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.processors.types import Word as ProcessorWord
 from reflector.settings import settings
-from reflector.storage import get_transcripts_storage
+from reflector.storage import get_recordings_storage, get_transcripts_storage
 from reflector.utils import generate_uuid4
-from sqlalchemy import Enum
-from sqlalchemy.sql import false, or_
+from reflector.utils.webvtt import topics_to_webvtt
 
 
 class SourceKind(enum.StrEnum):
@@ -33,7 +40,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),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime(timezone=True)),
     sqlalchemy.Column("title", sqlalchemy.String),
     sqlalchemy.Column("short_summary", sqlalchemy.String),
     sqlalchemy.Column("long_summary", sqlalchemy.String),
@@ -74,12 +81,38 @@ transcripts = sqlalchemy.Table(
     # the main "audio deleted" is the presence of the audio itself / consents not-given
     # 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"),
 )
 
+# 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(webvtt, '')), 'B')",
+                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)
@@ -144,14 +177,18 @@ 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: 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] = []
@@ -165,8 +202,8 @@ 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
 
     @field_serializer("created_at", when_used="json")
     def serialize_datetime(self, dt: datetime) -> str:
@@ -267,10 +304,12 @@ 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
 
-        from reflector.app import app
-        from reflector.views.transcripts import create_access_token
+        # 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
 
         path = app.url_path_for(
             "transcript_get_audio_mp3",
@@ -331,17 +370,9 @@ class TranscriptController:
         - `room_id`: filter transcripts by room ID
         - `search_term`: filter transcripts by search term
         """
-        from reflector.db.meetings import meetings
-        from reflector.db.recordings import recordings
-        from reflector.db.rooms import rooms
 
-        query = (
-            transcripts.select()
-            .join(
-                recordings, transcripts.c.recording_id == recordings.c.id, isouter=True
-            )
-            .join(meetings, recordings.c.meeting_id == meetings.c.id, isouter=True)
-            .join(rooms, meetings.c.room_id == rooms.c.id, isouter=True)
+        query = transcripts.select().join(
+            rooms, transcripts.c.room_id == rooms.c.id, isouter=True
         )
 
         if user_id:
@@ -355,7 +386,7 @@ class TranscriptController:
             query = query.where(transcripts.c.source_kind == source_kind)
 
         if room_id:
-            query = query.where(rooms.c.id == room_id)
+            query = query.where(transcripts.c.room_id == room_id)
 
         if search_term:
             query = query.where(transcripts.c.title.ilike(f"%{search_term}%"))
@@ -368,7 +399,6 @@ class TranscriptController:
         query = query.with_only_columns(
             transcript_columns
             + [
-                rooms.c.id.label("room_id"),
                 rooms.c.name.label("room_name"),
             ]
         )
@@ -390,7 +420,7 @@ class TranscriptController:
         if return_query:
             return query
 
-        results = await database.fetch_all(query)
+        results = await get_database().fetch_all(query)
         return results
 
     async def get_by_id(self, transcript_id: str, **kwargs) -> Transcript | None:
@@ -400,7 +430,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 database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Transcript(**result)
@@ -414,11 +444,27 @@ 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 database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             return None
         return Transcript(**result)
 
+    async def get_by_room_id(self, room_id: str, **kwargs) -> list[Transcript]:
+        """
+        Get transcripts by room_id (direct access without joins)
+        """
+        query = transcripts.select().where(transcripts.c.room_id == room_id)
+        if "user_id" in kwargs:
+            query = query.where(transcripts.c.user_id == kwargs["user_id"])
+        if "order_by" in kwargs:
+            order_by = kwargs["order_by"]
+            field = getattr(transcripts.c, order_by[1:])
+            if order_by.startswith("-"):
+                field = field.desc()
+            query = query.order_by(field)
+        results = await get_database().fetch_all(query)
+        return [Transcript(**result) for result in results]
+
     async def get_by_id_for_http(
         self,
         transcript_id: str,
@@ -434,7 +480,7 @@ class TranscriptController:
         to determine if the user can access the transcript.
         """
         query = transcripts.select().where(transcripts.c.id == transcript_id)
-        result = await database.fetch_one(query)
+        result = await get_database().fetch_one(query)
         if not result:
             raise HTTPException(status_code=404, detail="Transcript not found")
 
@@ -469,6 +515,8 @@ class TranscriptController:
         user_id: str | None = None,
         recording_id: str | None = None,
         share_mode: str = "private",
+        meeting_id: str | None = None,
+        room_id: str | None = None,
     ):
         """
         Add a new transcript
@@ -481,25 +529,56 @@ class TranscriptController:
             user_id=user_id,
             recording_id=recording_id,
             share_mode=share_mode,
+            meeting_id=meeting_id,
+            room_id=room_id,
         )
         query = transcripts.insert().values(**transcript.model_dump())
-        await database.execute(query)
+        await get_database().execute(query)
         return transcript
 
-    async def update(self, transcript: Transcript, values: dict, mutate=True):
+    # 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:
         """
-        Update a transcript fields with key/values in values
+        Update a transcript fields with key/values in values.
+        Returns a copy of the transcript with updated values.
         """
+        values = TranscriptController._handle_topics_update(values)
+
         query = (
             transcripts.update()
             .where(transcripts.c.id == transcript.id)
             .values(**values)
         )
-        await database.execute(query)
+        await get_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,
@@ -513,23 +592,55 @@ 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 database.execute(query)
+        await get_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 database.execute(query)
+        await get_database().execute(query)
 
     @asynccontextmanager
     async def transaction(self):
         """
         A context manager for database transaction
         """
-        async with database.transaction(isolation="serializable"):
+        async with get_database().transaction(isolation="serializable"):
             yield
 
     async def append_event(
@@ -542,11 +653,7 @@ class TranscriptController:
         Append an event to a transcript
         """
         resp = transcript.add_event(event=event, data=data)
-        await self.update(
-            transcript,
-            {"events": transcript.events_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"events": transcript.events_dump()})
         return resp
 
     async def upsert_topic(
@@ -558,11 +665,7 @@ class TranscriptController:
         Upsert topics to a transcript
         """
         transcript.upsert_topic(topic)
-        await self.update(
-            transcript,
-            {"topics": transcript.topics_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"topics": transcript.topics_dump()})
 
     async def move_mp3_to_storage(self, transcript: Transcript):
         """
@@ -587,7 +690,8 @@ class TranscriptController:
             )
 
             # indicate on the transcript that the audio is now on storage
-            await self.update(transcript, {"audio_location": "storage"})
+            # mutates transcript argument
+            await self.update(transcript, {"audio_location": "storage"}, mutate=True)
 
         # unlink the local file
         transcript.audio_mp3_filename.unlink(missing_ok=True)
@@ -611,11 +715,7 @@ class TranscriptController:
         Add/update a participant to a transcript
         """
         result = transcript.upsert_participant(participant)
-        await self.update(
-            transcript,
-            {"participants": transcript.participants_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"participants": transcript.participants_dump()})
         return result
 
     async def delete_participant(
@@ -627,11 +727,7 @@ class TranscriptController:
         Delete a participant from a transcript
         """
         transcript.delete_participant(participant_id)
-        await self.update(
-            transcript,
-            {"participants": transcript.participants_dump()},
-            mutate=False,
-        )
+        await self.update(transcript, {"participants": transcript.participants_dump()})
 
 
 transcripts_controller = TranscriptController()

server/reflector/db/utils.py

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

server/reflector/llm.py

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

server/reflector/llm/__init__.py

@@ -1,2 +0,0 @@
-from .base import LLM  # noqa: F401
-from .llm_params import LLMTaskParams  # noqa: F401

server/reflector/llm/base.py

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

server/reflector/llm/llm_modal.py

@@ -1,151 +0,0 @@
-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())

server/reflector/llm/llm_oobabooga.py

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

server/reflector/llm/llm_openai.py

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

server/reflector/llm/llm_params.py

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

server/reflector/pipelines/main_live_pipeline.py

@@ -14,10 +14,15 @@ 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, group, shared_task
+from celery import chord, current_task, group, shared_task
 from pydantic import BaseModel
+from structlog import BoundLogger as Logger
+
+from reflector.db import get_database
 from reflector.db.meetings import meeting_consent_controller, meetings_controller
 from reflector.db.recordings import recordings_controller
 from reflector.db.rooms import rooms_controller
@@ -33,7 +38,7 @@ from reflector.db.transcripts import (
     transcripts_controller,
 )
 from reflector.logger import logger
-from reflector.pipelines.runner import PipelineRunner
+from reflector.pipelines.runner import PipelineMessage, PipelineRunner
 from reflector.processors import (
     AudioChunkerProcessor,
     AudioDiarizationAutoProcessor,
@@ -45,7 +50,7 @@ from reflector.processors import (
     TranscriptFinalTitleProcessor,
     TranscriptLinerProcessor,
     TranscriptTopicDetectorProcessor,
-    TranscriptTranslatorProcessor,
+    TranscriptTranslatorAutoProcessor,
 )
 from reflector.processors.audio_waveform_processor import AudioWaveformProcessor
 from reflector.processors.types import AudioDiarizationInput
@@ -61,15 +66,13 @@ 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
-
+            database = get_database()
             await database.connect()
             try:
                 return await f(*args, **kwargs)
@@ -111,16 +114,29 @@ 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:
-            return await func(transcript=transcript, logger=tlogger, **kwargs)
+            result = await func(transcript=transcript, logger=tlogger, **kwargs)
+            return result
         except Exception as exc:
-            tlogger.error("Pipeline error", exc_info=exc)
+            tlogger.error("Pipeline error", function_name=func.__name__, exc_info=exc)
             raise
 
     return wrapper
@@ -130,7 +146,7 @@ class StrValue(BaseModel):
     value: str
 
 
-class PipelineMainBase(PipelineRunner):
+class PipelineMainBase(PipelineRunner[PipelineMessage], Generic[PipelineMessage]):
     transcript_id: str
     ws_room_id: str | None = None
     ws_manager: WebsocketManager | None = None
@@ -150,7 +166,11 @@ class PipelineMainBase(PipelineRunner):
             raise Exception("Transcript not found")
         return result
 
-    def get_transcript_topics(self, transcript: Transcript) -> list[TranscriptTopic]:
+    @staticmethod
+    def wrap_transcript_topics(
+        topics: list[TranscriptTopic],
+    ) -> list[TitleSummaryWithIdProcessorType]:
+        # transformation to a pipe-supported format
         return [
             TitleSummaryWithIdProcessorType(
                 id=topic.id,
@@ -160,7 +180,7 @@ class PipelineMainBase(PipelineRunner):
                 duration=topic.duration,
                 transcript=TranscriptProcessorType(words=topic.words),
             )
-            for topic in transcript.topics
+            for topic in topics
         ]
 
     @asynccontextmanager
@@ -347,7 +367,7 @@ class PipelineMainLive(PipelineMainBase):
             AudioMergeProcessor(),
             AudioTranscriptAutoProcessor.as_threaded(),
             TranscriptLinerProcessor(),
-            TranscriptTranslatorProcessor.as_threaded(callback=self.on_transcript),
+            TranscriptTranslatorAutoProcessor.as_threaded(callback=self.on_transcript),
             TranscriptTopicDetectorProcessor.as_threaded(callback=self.on_topic),
         ]
         pipeline = Pipeline(*processors)
@@ -366,7 +386,7 @@ class PipelineMainLive(PipelineMainBase):
         pipeline_post(transcript_id=self.transcript_id)
 
 
-class PipelineMainDiarization(PipelineMainBase):
+class PipelineMainDiarization(PipelineMainBase[AudioDiarizationInput]):
     """
     Diarize the audio and update topics
     """
@@ -390,11 +410,10 @@ class PipelineMainDiarization(PipelineMainBase):
             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=topics,
+            topics=self.wrap_transcript_topics(transcript.topics),
         )
 
         # as tempting to use pipeline.push, prefer to use the runner
@@ -407,7 +426,7 @@ class PipelineMainDiarization(PipelineMainBase):
         return pipeline
 
 
-class PipelineMainFromTopics(PipelineMainBase):
+class PipelineMainFromTopics(PipelineMainBase[TitleSummaryWithIdProcessorType]):
     """
     Pseudo class for generating a pipeline from topics
     """
@@ -429,7 +448,7 @@ class PipelineMainFromTopics(PipelineMainBase):
         pipeline.logger.info(f"{self.__class__.__name__} pipeline created")
 
         # push topics
-        topics = self.get_transcript_topics(transcript)
+        topics = PipelineMainBase.wrap_transcript_topics(transcript.topics)
         for topic in topics:
             await self.push(topic)
 
@@ -510,8 +529,6 @@ 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:
@@ -590,7 +607,7 @@ async def cleanup_consent(transcript: Transcript, logger: Logger):
                         meeting.id
                     )
     except Exception as e:
-        logger.error(f"Failed to get fetch consent: {e}")
+        logger.error(f"Failed to get fetch consent: {e}", exc_info=e)
         consent_denied = True
 
     if not consent_denied:
@@ -613,7 +630,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}")
+            logger.error(f"Failed to delete Whereby recording: {e}", exc_info=e)
 
     # non-transactional, files marked for deletion not actually deleted is possible
     await transcripts_controller.update(transcript, {"audio_deleted": True})
@@ -626,7 +643,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}")
+            logger.error(f"Failed to delete processed audio: {e}", exc_info=e)
 
     # 3. Delete local audio files
     try:
@@ -635,7 +652,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}")
+        logger.error(f"Failed to delete local audio files: {e}", exc_info=e)
 
     logger.info("Consent cleanup done")
 
@@ -780,8 +797,6 @@ def pipeline_post(*, transcript_id: str):
 
 @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)

server/reflector/pipelines/runner.py

@@ -16,13 +16,17 @@ 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):
+
+class PipelineRunner(BaseModel, Generic[PipelineMessage]):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     status: str = "idle"
@@ -66,7 +70,7 @@ class PipelineRunner(BaseModel):
         coro = self.run()
         asyncio.run(coro)
 
-    async def push(self, data):
+    async def push(self, data: PipelineMessage):
         """
         Push data to the pipeline
         """
@@ -91,7 +95,11 @@ class PipelineRunner(BaseModel):
         pass
 
     async def _add_cmd(
-        self, cmd: str, data, max_retries: int = 3, retry_time_limit: int = 3
+        self,
+        cmd: str,
+        data: PipelineMessage,
+        max_retries: int = 3,
+        retry_time_limit: int = 3,
     ):
         """
         Enqueue a command to be executed in the runner.
@@ -142,7 +150,10 @@ class PipelineRunner(BaseModel):
                 cmd, data = await self._q_cmd.get()
                 func = getattr(self, f"cmd_{cmd.lower()}")
                 if func:
-                    await func(data)
+                    if cmd.upper() == "FLUSH":
+                        await func()
+                    else:
+                        await func(data)
                 else:
                     raise Exception(f"Unknown command {cmd}")
         except Exception:
@@ -151,13 +162,13 @@ class PipelineRunner(BaseModel):
             self._ev_done.set()
             raise
 
-    async def cmd_push(self, data):
+    async def cmd_push(self, data: PipelineMessage):
         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, data):
+    async def cmd_flush(self):
         await self._set_status("flush")
         await self.pipeline.flush()
         await self._set_status("ended")

server/reflector/processors/__init__.py

@@ -16,6 +16,7 @@ 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,

server/reflector/processors/audio_chunker.py

@@ -1,6 +1,7 @@
-from reflector.processors.base import Processor
 import av
 
+from reflector.processors.base import Processor
+
 
 class AudioChunkerProcessor(Processor):
     """

server/reflector/processors/audio_diarization.py

@@ -1,5 +1,9 @@
 from reflector.processors.base import Processor
-from reflector.processors.types import AudioDiarizationInput, TitleSummary, Word
+from reflector.processors.types import (
+    AudioDiarizationInput,
+    TitleSummary,
+    Word,
+)
 
 
 class AudioDiarizationProcessor(Processor):

server/reflector/processors/audio_diarization_modal.py

@@ -1,4 +1,5 @@
 import httpx
+
 from reflector.processors.audio_diarization import AudioDiarizationProcessor
 from reflector.processors.audio_diarization_auto import AudioDiarizationAutoProcessor
 from reflector.processors.types import AudioDiarizationInput, TitleSummary
@@ -9,12 +10,17 @@ class AudioDiarizationModalProcessor(AudioDiarizationProcessor):
     INPUT_TYPE = AudioDiarizationInput
     OUTPUT_TYPE = TitleSummary
 
-    def __init__(self, **kwargs):
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
         super().__init__(**kwargs)
+        if not settings.DIARIZATION_URL:
+            raise Exception(
+                "DIARIZATION_URL required to use AudioDiarizationModalProcessor"
+            )
         self.diarization_url = settings.DIARIZATION_URL + "/diarize"
-        self.headers = {
-            "Authorization": f"Bearer {settings.LLM_MODAL_API_KEY}",
-        }
+        self.modal_api_key = modal_api_key
+        self.headers = {}
+        if self.modal_api_key:
+            self.headers["Authorization"] = f"Bearer {self.modal_api_key}"
 
     async def _diarize(self, data: AudioDiarizationInput):
         # Gather diarization data

server/reflector/processors/audio_file_writer.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
 import av
+
 from reflector.processors.base import Processor
 
 

server/reflector/processors/audio_merge.py

@@ -1,10 +1,12 @@
-from reflector.processors.base import Processor
-from reflector.processors.types import AudioFile
+import io
 from time import monotonic_ns
 from uuid import uuid4
-import io
+
 import av
 
+from reflector.processors.base import Processor
+from reflector.processors.types import AudioFile
+
 
 class AudioMergeProcessor(Processor):
     """

server/reflector/processors/audio_transcript.py

@@ -1,4 +1,5 @@
 from prometheus_client import Counter, Histogram
+
 from reflector.processors.base import Processor
 from reflector.processors.types import AudioFile, Transcript
 

server/reflector/processors/audio_transcript_modal.py

@@ -13,6 +13,7 @@ API will be a POST request to TRANSCRIPT_URL:
 """
 
 from openai import AsyncOpenAI
+
 from reflector.processors.audio_transcript import AudioTranscriptProcessor
 from reflector.processors.audio_transcript_auto import AudioTranscriptAutoProcessor
 from reflector.processors.types import AudioFile, Transcript, Word
@@ -20,16 +21,20 @@ from reflector.settings import settings
 
 
 class AudioTranscriptModalProcessor(AudioTranscriptProcessor):
-    def __init__(self, modal_api_key: str):
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
         super().__init__()
+        if not settings.TRANSCRIPT_URL:
+            raise Exception(
+                "TRANSCRIPT_URL required to use AudioTranscriptModalProcessor"
+            )
         self.transcript_url = settings.TRANSCRIPT_URL + "/v1"
         self.timeout = settings.TRANSCRIPT_TIMEOUT
-        self.api_key = settings.TRANSCRIPT_MODAL_API_KEY
+        self.modal_api_key = modal_api_key
 
     async def _transcript(self, data: AudioFile):
         async with AsyncOpenAI(
             base_url=self.transcript_url,
-            api_key=self.api_key,
+            api_key=self.modal_api_key,
             timeout=self.timeout,
         ) as client:
             self.logger.debug(f"Try to transcribe audio {data.name}")

server/reflector/processors/audio_transcript_whisper.py

@@ -1,4 +1,5 @@
 from faster_whisper import WhisperModel
+
 from reflector.processors.audio_transcript import AudioTranscriptProcessor
 from reflector.processors.audio_transcript_auto import AudioTranscriptAutoProcessor
 from reflector.processors.types import AudioFile, Transcript, Word

server/reflector/processors/base.py

@@ -5,6 +5,7 @@ from uuid import uuid4
 
 from prometheus_client import Counter, Gauge, Histogram
 from pydantic import BaseModel
+
 from reflector.logger import logger
 
 

server/reflector/processors/transcript_final_summary.py

@@ -2,6 +2,7 @@ from reflector.llm import LLM
 from reflector.processors.base import Processor
 from reflector.processors.summary.summary_builder import SummaryBuilder
 from reflector.processors.types import FinalLongSummary, FinalShortSummary, TitleSummary
+from reflector.settings import settings
 
 
 class TranscriptFinalSummaryProcessor(Processor):
@@ -16,14 +17,14 @@ class TranscriptFinalSummaryProcessor(Processor):
         super().__init__(**kwargs)
         self.transcript = transcript
         self.chunks: list[TitleSummary] = []
-        self.llm = LLM.get_instance(model_name="NousResearch/Hermes-3-Llama-3.1-8B")
+        self.llm = LLM(settings=settings)
         self.builder = None
 
     async def _push(self, data: TitleSummary):
         self.chunks.append(data)
 
     async def get_summary_builder(self, text) -> SummaryBuilder:
-        builder = SummaryBuilder(self.llm)
+        builder = SummaryBuilder(self.llm, logger=self.logger)
         builder.set_transcript(text)
         await builder.identify_participants()
         await builder.generate_summary()

server/reflector/processors/transcript_final_title.py

@@ -1,67 +1,72 @@
-from reflector.llm import LLM, LLMTaskParams
+from textwrap import dedent
+
+from reflector.llm import LLM
 from reflector.processors.base import Processor
 from reflector.processors.types import FinalTitle, TitleSummary
+from reflector.settings import settings
+from reflector.utils.text import clean_title
+
+TITLE_PROMPT = dedent(
+    """
+    Generate a concise title for this meeting based on the following topic titles.
+    Ignore casual conversation, greetings, or administrative matters.
+
+    The title must:
+    - Be maximum 10 words
+    - Use noun phrases when possible (e.g., "Q1 Budget Review" not "Reviewing the Q1 Budget")
+    - Avoid generic terms like "Team Meeting" or "Discussion"
+
+    If multiple unrelated topics were discussed, prioritize the most significant one.
+    or create a compound title (e.g., "Product Launch and Budget Planning").
+
+    <topics_discussed>
+    {titles}
+    </topics_discussed>
+
+    Do not explain, just output the meeting title as a single line.
+    """
+).strip()
 
 
 class TranscriptFinalTitleProcessor(Processor):
     """
-    Assemble all summary into a line-based json
+    Generate a final title from topic titles using LlamaIndex
     """
 
     INPUT_TYPE = TitleSummary
     OUTPUT_TYPE = FinalTitle
-    TASK = "final_title"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.chunks: list[TitleSummary] = []
-        self.llm = LLM.get_instance()
-        self.params = LLMTaskParams.get_instance(self.TASK).task_params
+        self.llm = LLM(settings=settings, temperature=0.5, max_tokens=200)
 
     async def _push(self, data: TitleSummary):
         self.chunks.append(data)
 
-    async def get_title(self, text: str) -> dict:
+    async def get_title(self, accumulated_titles: str) -> str:
         """
-        Generate a title for the whole recording
+        Generate a title for the whole recording using LLM
         """
-        chunks = list(self.llm.split_corpus(corpus=text, task_params=self.params))
+        prompt = TITLE_PROMPT.format(titles=accumulated_titles)
+        response = await self.llm.get_response(
+            prompt,
+            [accumulated_titles],
+            tone_name="Title generator",
+        )
 
-        if len(chunks) == 1:
-            chunk = chunks[0]
-            prompt = self.llm.create_prompt(instruct=self.params.instruct, text=chunk)
-            title_result = await self.llm.generate(
-                prompt=prompt,
-                gen_schema=self.params.gen_schema,
-                gen_cfg=self.params.gen_cfg,
-                logger=self.logger,
-            )
-            return title_result
-        else:
-            accumulated_titles = ""
-            for chunk in chunks:
-                prompt = self.llm.create_prompt(
-                    instruct=self.params.instruct, text=chunk
-                )
-                title_result = await self.llm.generate(
-                    prompt=prompt,
-                    gen_schema=self.params.gen_schema,
-                    gen_cfg=self.params.gen_cfg,
-                    logger=self.logger,
-                )
-                accumulated_titles += title_result["summary"]
+        self.logger.info(f"Generated title response: {response}")
 
-            return await self.get_title(accumulated_titles)
+        return response
 
     async def _flush(self):
         if not self.chunks:
             self.logger.warning("No summary to output")
             return
 
-        accumulated_titles = ".".join([chunk.title for chunk in self.chunks])
-        title_result = await self.get_title(accumulated_titles)
-        final_title = self.llm.trim_title(title_result["title"])
-        final_title = self.llm.ensure_casing(final_title)
+        accumulated_titles = "\n".join([f"- {chunk.title}" for chunk in self.chunks])
+        title = await self.get_title(accumulated_titles)
+        title = clean_title(title)
 
-        final_title = FinalTitle(title=final_title)
+        final_title = FinalTitle(title=title)
         await self.emit(final_title)

server/reflector/processors/transcript_topic_detector.py

@@ -1,7 +1,41 @@
-from reflector.llm import LLM, LLMTaskParams
+from textwrap import dedent
+
+from pydantic import BaseModel, Field
+
+from reflector.llm import LLM
 from reflector.processors.base import Processor
 from reflector.processors.types import TitleSummary, Transcript
 from reflector.settings import settings
+from reflector.utils.text import clean_title
+
+TOPIC_PROMPT = dedent(
+    """
+    Analyze the following transcript segment and extract the main topic being discussed.
+    Focus on the substantive content and ignore small talk or administrative chatter.
+
+    Create a title that:
+    - Captures the specific subject matter being discussed
+    - Is descriptive and self-explanatory
+    - Uses professional language
+    - Is specific rather than generic
+
+    For the summary:
+    - Summarize the key points in maximum two sentences
+    - Focus on what was discussed, decided, or accomplished
+    - Be concise but informative
+
+    <transcript>
+    {text}
+    </transcript>
+    """
+).strip()
+
+
+class TopicResponse(BaseModel):
+    """Structured response for topic detection"""
+
+    title: str = Field(description="A descriptive title for the topic being discussed")
+    summary: str = Field(description="A concise 1-2 sentence summary of the discussion")
 
 
 class TranscriptTopicDetectorProcessor(Processor):
@@ -11,7 +45,6 @@ class TranscriptTopicDetectorProcessor(Processor):
 
     INPUT_TYPE = Transcript
     OUTPUT_TYPE = TitleSummary
-    TASK = "topic"
 
     def __init__(
         self, min_transcript_length: int = int(settings.MIN_TRANSCRIPT_LENGTH), **kwargs
@@ -19,8 +52,7 @@ class TranscriptTopicDetectorProcessor(Processor):
         super().__init__(**kwargs)
         self.transcript = None
         self.min_transcript_length = min_transcript_length
-        self.llm = LLM.get_instance()
-        self.params = LLMTaskParams.get_instance(self.TASK).task_params
+        self.llm = LLM(settings=settings, temperature=0.9, max_tokens=500)
 
     async def _push(self, data: Transcript):
         if self.transcript is None:
@@ -34,18 +66,15 @@ class TranscriptTopicDetectorProcessor(Processor):
             return
         await self.flush()
 
-    async def get_topic(self, text: str) -> dict:
+    async def get_topic(self, text: str) -> TopicResponse:
         """
-        Generate a topic and description for a transcription excerpt
+        Generate a topic and description for a transcription excerpt using LLM
         """
-        prompt = self.llm.create_prompt(instruct=self.params.instruct, text=text)
-        topic_result = await self.llm.generate(
-            prompt=prompt,
-            gen_schema=self.params.gen_schema,
-            gen_cfg=self.params.gen_cfg,
-            logger=self.logger,
+        prompt = TOPIC_PROMPT.format(text=text)
+        response = await self.llm.get_structured_response(
+            prompt, [text], TopicResponse, tone_name="Topic analyzer"
         )
-        return topic_result
+        return response
 
     async def _flush(self):
         if not self.transcript:
@@ -53,13 +82,13 @@ class TranscriptTopicDetectorProcessor(Processor):
 
         text = self.transcript.text
         self.logger.info(f"Topic detector got {len(text)} length transcript")
+
         topic_result = await self.get_topic(text=text)
-        title = self.llm.trim_title(topic_result["title"])
-        title = self.llm.ensure_casing(title)
+        title = clean_title(topic_result.title)
 
         summary = TitleSummary(
             title=title,
-            summary=topic_result["summary"],
+            summary=topic_result.summary,
             timestamp=self.transcript.timestamp,
             duration=self.transcript.duration,
             transcript=self.transcript,

server/reflector/processors/transcript_translator.py

@@ -1,8 +1,5 @@
-import httpx
 from reflector.processors.base import Processor
-from reflector.processors.types import Transcript, TranslationLanguages
-from reflector.settings import settings
-from reflector.utils.retry import retry
+from reflector.processors.types import Transcript
 
 
 class TranscriptTranslatorProcessor(Processor):
@@ -12,60 +9,27 @@ class TranscriptTranslatorProcessor(Processor):
 
     INPUT_TYPE = Transcript
     OUTPUT_TYPE = Transcript
-    TASK = "translate"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.transcript = None
-        self.translate_url = settings.TRANSLATE_URL
-        self.timeout = settings.TRANSLATE_TIMEOUT
-        self.headers = {"Authorization": f"Bearer {settings.LLM_MODAL_API_KEY}"}
 
     async def _push(self, data: Transcript):
         self.transcript = data
         await self.flush()
 
-    async def get_translation(self, text: str) -> str | None:
-        # FIXME this should be a processor after, as each user may want
-        # different languages
-
-        source_language = self.get_pref("audio:source_language", "en")
-        target_language = self.get_pref("audio:target_language", "en")
-        if source_language == target_language:
-            return
-
-        languages = TranslationLanguages()
-        # Only way to set the target should be the UI element like dropdown.
-        # Hence, this assert should never fail.
-        assert languages.is_supported(target_language)
-        self.logger.debug(f"Try to translate {text=}")
-        json_payload = {
-            "text": text,
-            "source_language": source_language,
-            "target_language": target_language,
-        }
-
-        async with httpx.AsyncClient() as client:
-            response = await retry(client.post)(
-                self.translate_url + "/translate",
-                headers=self.headers,
-                params=json_payload,
-                timeout=self.timeout,
-                follow_redirects=True,
-            )
-            response.raise_for_status()
-            result = response.json()["text"]
-
-            # Sanity check for translation status in the result
-            if target_language in result:
-                translation = result[target_language]
-            self.logger.debug(f"Translation response: {text=}, {translation=}")
-        return translation
+    async def _translate(self, text: str) -> str | None:
+        raise NotImplementedError
 
     async def _flush(self):
         if not self.transcript:
             return
-        self.transcript.translation = await self.get_translation(
-            text=self.transcript.text
-        )
+
+        source_language = self.get_pref("audio:source_language", "en")
+        target_language = self.get_pref("audio:target_language", "en")
+        if source_language == target_language:
+            self.transcript.translation = None
+        else:
+            self.transcript.translation = await self._translate(self.transcript.text)
+
         await self.emit(self.transcript)

server/reflector/processors/transcript_translator_auto.py

@@ -0,0 +1,32 @@
+import importlib
+
+from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+from reflector.settings import settings
+
+
+class TranscriptTranslatorAutoProcessor(TranscriptTranslatorProcessor):
+    _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.TRANSLATION_BACKEND
+        if name not in cls._registry:
+            module_name = f"reflector.processors.transcript_translator_{name}"
+            importlib.import_module(module_name)
+
+        # gather specific configuration for the processor
+        # search `TRANSLATION_BACKEND_XXX_YYY`, push to constructor as `backend_xxx_yyy`
+        config = {}
+        name_upper = name.upper()
+        settings_prefix = "TRANSLATION_"
+        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)

server/reflector/processors/transcript_translator_modal.py

@@ -0,0 +1,66 @@
+import httpx
+
+from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+from reflector.processors.transcript_translator_auto import (
+    TranscriptTranslatorAutoProcessor,
+)
+from reflector.processors.types import TranslationLanguages
+from reflector.settings import settings
+from reflector.utils.retry import retry
+
+
+class TranscriptTranslatorModalProcessor(TranscriptTranslatorProcessor):
+    """
+    Translate the transcript into the target language using Modal.com
+    """
+
+    def __init__(self, modal_api_key: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        if not settings.TRANSLATE_URL:
+            raise Exception(
+                "TRANSLATE_URL is required for TranscriptTranslatorModalProcessor"
+            )
+        self.translate_url = settings.TRANSLATE_URL
+        self.timeout = settings.TRANSLATE_TIMEOUT
+        self.modal_api_key = modal_api_key
+        self.headers = {}
+        if self.modal_api_key:
+            self.headers["Authorization"] = f"Bearer {self.modal_api_key}"
+
+    async def _translate(self, text: str) -> str | None:
+        source_language = self.get_pref("audio:source_language", "en")
+        target_language = self.get_pref("audio:target_language", "en")
+
+        languages = TranslationLanguages()
+        # Only way to set the target should be the UI element like dropdown.
+        # Hence, this assert should never fail.
+        assert languages.is_supported(target_language)
+        self.logger.debug(f"Try to translate {text=}")
+        json_payload = {
+            "text": text,
+            "source_language": source_language,
+            "target_language": target_language,
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await retry(client.post)(
+                self.translate_url + "/translate",
+                headers=self.headers,
+                params=json_payload,
+                timeout=self.timeout,
+                follow_redirects=True,
+                logger=self.logger,
+            )
+            response.raise_for_status()
+            result = response.json()["text"]
+
+            # Sanity check for translation status in the result
+            if target_language in result:
+                translation = result[target_language]
+            else:
+                translation = None
+            self.logger.debug(f"Translation response: {text=}, {translation=}")
+        return translation
+
+
+TranscriptTranslatorAutoProcessor.register("modal", TranscriptTranslatorModalProcessor)

server/reflector/processors/transcript_translator_passthrough.py

@@ -0,0 +1,14 @@
+from reflector.processors.transcript_translator import TranscriptTranslatorProcessor
+from reflector.processors.transcript_translator_auto import (
+    TranscriptTranslatorAutoProcessor,
+)
+
+
+class TranscriptTranslatorPassthroughProcessor(TranscriptTranslatorProcessor):
+    async def _translate(self, text: str) -> None:
+        return None
+
+
+TranscriptTranslatorAutoProcessor.register(
+    "passthrough", TranscriptTranslatorPassthroughProcessor
+)

server/reflector/processors/types.py

@@ -2,9 +2,11 @@ import io
 import re
 import tempfile
 from pathlib import Path
+from typing import Annotated
 
 from profanityfilter import ProfanityFilter
-from pydantic import BaseModel, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr
+
 from reflector.redis_cache import redis_cache
 
 PUNC_RE = re.compile(r"[.;:?!…]")
@@ -47,20 +49,70 @@ class AudioFile(BaseModel):
             self._path.unlink()
 
 
+# non-negative seconds with float part
+Seconds = Annotated[float, Field(ge=0.0, description="Time in seconds with float part")]
+
+
 class Word(BaseModel):
     text: str
-    start: float
-    end: float
+    start: Seconds
+    end: Seconds
     speaker: int = 0
 
 
 class TranscriptSegment(BaseModel):
     text: str
-    start: float
-    end: float
+    start: Seconds
+    end: Seconds
     speaker: int = 0
 
 
+def words_to_segments(words: list[Word]) -> list[TranscriptSegment]:
+    # from a list of word, create a list of segments
+    # join the word that are less than 2 seconds apart
+    # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
+    segments = []
+    current_segment = None
+    MAX_SEGMENT_LENGTH = 120
+
+    for word in words:
+        if current_segment is None:
+            current_segment = TranscriptSegment(
+                text=word.text,
+                start=word.start,
+                end=word.end,
+                speaker=word.speaker,
+            )
+            continue
+
+        # If the word is attach to another speaker, push the current segment
+        # and start a new one
+        if word.speaker != current_segment.speaker:
+            segments.append(current_segment)
+            current_segment = TranscriptSegment(
+                text=word.text,
+                start=word.start,
+                end=word.end,
+                speaker=word.speaker,
+            )
+            continue
+
+        # if the word is the end of a sentence, and we have enough content,
+        # add the word to the current segment and push it
+        current_segment.text += word.text
+        current_segment.end = word.end
+
+        have_punc = PUNC_RE.search(word.text)
+        if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
+            segments.append(current_segment)
+            current_segment = None
+
+    if current_segment:
+        segments.append(current_segment)
+
+    return segments
+
+
 class Transcript(BaseModel):
     translation: str | None = None
     words: list[Word] = None
@@ -116,49 +168,7 @@ class Transcript(BaseModel):
         return Transcript(text=self.text, translation=self.translation, words=words)
 
     def as_segments(self) -> list[TranscriptSegment]:
-        # from a list of word, create a list of segments
-        # join the word that are less than 2 seconds apart
-        # but separate if the speaker changes, or if the punctuation is a . , ; : ? !
-        segments = []
-        current_segment = None
-        MAX_SEGMENT_LENGTH = 120
-
-        for word in self.words:
-            if current_segment is None:
-                current_segment = TranscriptSegment(
-                    text=word.text,
-                    start=word.start,
-                    end=word.end,
-                    speaker=word.speaker,
-                )
-                continue
-
-            # If the word is attach to another speaker, push the current segment
-            # and start a new one
-            if word.speaker != current_segment.speaker:
-                segments.append(current_segment)
-                current_segment = TranscriptSegment(
-                    text=word.text,
-                    start=word.start,
-                    end=word.end,
-                    speaker=word.speaker,
-                )
-                continue
-
-            # if the word is the end of a sentence, and we have enough content,
-            # add the word to the current segment and push it
-            current_segment.text += word.text
-            current_segment.end = word.end
-
-            have_punc = PUNC_RE.search(word.text)
-            if have_punc and (len(current_segment.text) > MAX_SEGMENT_LENGTH):
-                segments.append(current_segment)
-                current_segment = None
-
-        if current_segment:
-            segments.append(current_segment)
-
-        return segments
+        return words_to_segments(self.words)
 
 
 class TitleSummary(BaseModel):

server/reflector/redis_cache.py

@@ -2,6 +2,7 @@ import functools
 import json
 
 import redis
+
 from reflector.settings import settings
 
 redis_clients = {}