Merge branch 'dev' into sur-90-feat-comments-in-chats

.env.example

@@ -9,7 +9,6 @@ FRONTEND_PORT=3000
 NEXT_PUBLIC_FASTAPI_BACKEND_URL=http://localhost:8000 (Default: http://localhost:8000)
 NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE=LOCAL or GOOGLE (Default: LOCAL)
 NEXT_PUBLIC_ETL_SERVICE=UNSTRUCTURED or LLAMACLOUD or DOCLING (Default: DOCLING)
-
 # Backend Configuration
 BACKEND_PORT=8000
 
@@ -19,6 +18,17 @@ POSTGRES_PASSWORD=postgres
 POSTGRES_DB=surfsense
 POSTGRES_PORT=5432
 
+# Electric-SQL Configuration
+ELECTRIC_PORT=5133
+# PostgreSQL host for Electric connection
+# - 'db' for Docker PostgreSQL (service name in docker-compose)
+# - 'host.docker.internal' for local PostgreSQL (recommended when Electric runs in Docker)
+#   Note: host.docker.internal works on Docker Desktop (Mac/Windows) and can be enabled on Linux
+POSTGRES_HOST=db
+ELECTRIC_DB_USER=electric
+ELECTRIC_DB_PASSWORD=electric_password
+NEXT_PUBLIC_ELECTRIC_URL=http://localhost:5133
+
 # pgAdmin Configuration
 PGADMIN_PORT=5050
 PGADMIN_DEFAULT_EMAIL=admin@surfsense.com

Dockerfile.allinone

@@ -1,10 +1,11 @@
 # SurfSense All-in-One Docker Image
-# This image bundles PostgreSQL+pgvector, Redis, Backend, and Frontend
-# Usage: docker run -d -p 3000:3000 -p 8000:8000 -v surfsense-data:/data --name surfsense ghcr.io/modsetter/surfsense:latest
+# This image bundles PostgreSQL+pgvector, Redis, Electric SQL, Backend, and Frontend
+# Usage: docker run -d -p 3000:3000 -p 8000:8000 -p 5133:5133 -v surfsense-data:/data --name surfsense ghcr.io/modsetter/surfsense:latest
 #
 # Included Services (all run locally by default):
 # - PostgreSQL 14 + pgvector (vector database)
 # - Redis (task queue)
+# - Electric SQL (real-time sync)
 # - Docling (document processing, CPU-only, OCR disabled)
 # - Kokoro TTS (local text-to-speech for podcasts)
 # - Faster-Whisper (local speech-to-text for audio files)
@@ -14,7 +15,12 @@
 # will be available in the future for faster AI inference.
 
 # ====================
-# Stage 1: Build Frontend
+# Stage 1: Get Electric SQL Binary
+# ====================
+FROM electricsql/electric:latest AS electric-builder
+
+# ====================
+# Stage 2: Build Frontend
 # ====================
 FROM node:20-alpine AS frontend-builder
 
@@ -42,12 +48,14 @@ RUN pnpm fumadocs-mdx
 ENV NEXT_PUBLIC_FASTAPI_BACKEND_URL=__NEXT_PUBLIC_FASTAPI_BACKEND_URL__
 ENV NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE=__NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE__
 ENV NEXT_PUBLIC_ETL_SERVICE=__NEXT_PUBLIC_ETL_SERVICE__
+ENV NEXT_PUBLIC_ELECTRIC_URL=__NEXT_PUBLIC_ELECTRIC_URL__
+ENV NEXT_PUBLIC_ELECTRIC_AUTH_MODE=__NEXT_PUBLIC_ELECTRIC_AUTH_MODE__
 
 # Build
 RUN pnpm run build
 
 # ====================
-# Stage 2: Runtime Image
+# Stage 3: Runtime Image
 # ====================
 FROM ubuntu:22.04 AS runtime
 
@@ -167,6 +175,11 @@ COPY --from=frontend-builder /app/public ./public
 
 COPY surfsense_web/content/docs /app/surfsense_web/content/docs
 
+# ====================
+# Copy Electric SQL Release
+# ====================
+COPY --from=electric-builder /app /app/electric-release
+
 # ====================
 # Setup Backend
 # ====================
@@ -238,11 +251,22 @@ ENV NEXT_PUBLIC_FASTAPI_BACKEND_URL=http://localhost:8000
 ENV NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE=LOCAL
 ENV NEXT_PUBLIC_ETL_SERVICE=DOCLING
 
+# Electric SQL configuration (ELECTRIC_DATABASE_URL is built dynamically by entrypoint from these values)
+ENV ELECTRIC_DB_USER=electric
+ENV ELECTRIC_DB_PASSWORD=electric_password
+# Note: ELECTRIC_DATABASE_URL is NOT set here - entrypoint builds it dynamically from ELECTRIC_DB_USER/PASSWORD
+ENV ELECTRIC_INSECURE=true
+ENV ELECTRIC_WRITE_TO_PG_MODE=direct
+ENV ELECTRIC_PORT=5133
+ENV PORT=5133
+ENV NEXT_PUBLIC_ELECTRIC_URL=http://localhost:5133
+ENV NEXT_PUBLIC_ELECTRIC_AUTH_MODE=insecure
+
 # Data volume
 VOLUME ["/data"]
 
-# Expose ports
-EXPOSE 3000 8000
+# Expose ports (Frontend: 3000, Backend: 8000, Electric: 5133)
+EXPOSE 3000 8000 5133
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \

docker-compose.yml

@@ -7,10 +7,15 @@ services:
       - "${POSTGRES_PORT:-5432}:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
+      - ./scripts/docker/postgresql.conf:/etc/postgresql/postgresql.conf:ro
+      - ./scripts/docker/init-electric-user.sh:/docker-entrypoint-initdb.d/init-electric-user.sh:ro
     environment:
       - POSTGRES_USER=${POSTGRES_USER:-postgres}
       - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-postgres}
       - POSTGRES_DB=${POSTGRES_DB:-surfsense}
+      - ELECTRIC_DB_USER=${ELECTRIC_DB_USER:-electric}
+      - ELECTRIC_DB_PASSWORD=${ELECTRIC_DB_PASSWORD:-electric_password}
+    command: postgres -c config_file=/etc/postgresql/postgresql.conf
 
   pgadmin:
     image: dpage/pgadmin4
@@ -51,11 +56,14 @@ services:
       - UNSTRUCTURED_HAS_PATCHED_LOOP=1
       - LANGCHAIN_TRACING_V2=false
       - LANGSMITH_TRACING=false
+      - ELECTRIC_DB_USER=${ELECTRIC_DB_USER:-electric}
+      - ELECTRIC_DB_PASSWORD=${ELECTRIC_DB_PASSWORD:-electric_password}
+      - NEXT_FRONTEND_URL=http://frontend:3000
     depends_on:
       - db
       - redis
 
-  # Run these services seperately in production
+  # Run these services separately in production
   # celery_worker:
   #   build: ./surfsense_backend
   #   # image: ghcr.io/modsetter/surfsense_backend:latest
@@ -110,6 +118,23 @@ services:
   #     - redis
   #     - celery_worker
 
+  electric:
+    image: electricsql/electric:latest
+    ports:
+      - "${ELECTRIC_PORT:-5133}:3000"
+    environment:
+      - DATABASE_URL=${ELECTRIC_DATABASE_URL:-postgresql://${ELECTRIC_DB_USER:-electric}:${ELECTRIC_DB_PASSWORD:-electric_password}@${POSTGRES_HOST:-db}:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-surfsense}?sslmode=disable}
+      - ELECTRIC_INSECURE=true
+      - ELECTRIC_WRITE_TO_PG_MODE=direct
+    restart: unless-stopped
+    # depends_on:
+    #   - db
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/v1/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
   frontend:
     build:
       context: ./surfsense_web
@@ -122,8 +147,12 @@ services:
       - "${FRONTEND_PORT:-3000}:3000"
     env_file:
       - ./surfsense_web/.env
+    environment:
+      - NEXT_PUBLIC_ELECTRIC_URL=${NEXT_PUBLIC_ELECTRIC_URL:-http://localhost:5133}
+      - NEXT_PUBLIC_ELECTRIC_AUTH_MODE=insecure
     depends_on:
       - backend
+      - electric
 
 volumes:
   postgres_data:

scripts/docker/entrypoint-allinone.sh

@@ -42,6 +42,31 @@ if [ -z "$STT_SERVICE" ]; then
     echo "✅ Using default STT_SERVICE: local/base"
 fi
 
+# ================================================
+# Set Electric SQL configuration
+# ================================================
+export ELECTRIC_DB_USER="${ELECTRIC_DB_USER:-electric}"
+export ELECTRIC_DB_PASSWORD="${ELECTRIC_DB_PASSWORD:-electric_password}"
+if [ -z "$ELECTRIC_DATABASE_URL" ]; then
+    export ELECTRIC_DATABASE_URL="postgresql://${ELECTRIC_DB_USER}:${ELECTRIC_DB_PASSWORD}@localhost:5432/${POSTGRES_DB:-surfsense}?sslmode=disable"
+    echo "✅ Electric SQL URL configured dynamically"
+else
+    # Ensure sslmode=disable is in the URL if not already present
+    if [[ "$ELECTRIC_DATABASE_URL" != *"sslmode="* ]]; then
+        # Add sslmode=disable (handle both cases: with or without existing query params)
+        if [[ "$ELECTRIC_DATABASE_URL" == *"?"* ]]; then
+            export ELECTRIC_DATABASE_URL="${ELECTRIC_DATABASE_URL}&sslmode=disable"
+        else
+            export ELECTRIC_DATABASE_URL="${ELECTRIC_DATABASE_URL}?sslmode=disable"
+        fi
+    fi
+    echo "✅ Electric SQL URL configured from environment"
+fi
+
+# Set Electric SQL port
+export ELECTRIC_PORT="${ELECTRIC_PORT:-5133}"
+export PORT="${ELECTRIC_PORT}"
+
 # ================================================
 # Initialize PostgreSQL if needed
 # ================================================
@@ -60,6 +85,11 @@ if [ ! -f /data/postgres/PG_VERSION ]; then
     echo "local all all trust" >> /data/postgres/pg_hba.conf
     echo "listen_addresses='*'" >> /data/postgres/postgresql.conf
     
+    # Enable logical replication for Electric SQL
+    echo "wal_level = logical" >> /data/postgres/postgresql.conf
+    echo "max_replication_slots = 10" >> /data/postgres/postgresql.conf
+    echo "max_wal_senders = 10" >> /data/postgres/postgresql.conf
+    
     # Start PostgreSQL temporarily to create database and user
     su - postgres -c "/usr/lib/postgresql/14/bin/pg_ctl -D /data/postgres -l /tmp/postgres_init.log start"
     
@@ -73,6 +103,35 @@ if [ ! -f /data/postgres/PG_VERSION ]; then
     # Enable pgvector extension
     su - postgres -c "psql -d ${POSTGRES_DB:-surfsense} -c 'CREATE EXTENSION IF NOT EXISTS vector;'"
     
+    # Create Electric SQL replication user (idempotent - uses IF NOT EXISTS)
+    echo "📡 Creating Electric SQL replication user..."
+    su - postgres -c "psql -d ${POSTGRES_DB:-surfsense} <<-EOSQL
+        DO \\\$\\\$
+        BEGIN
+            IF NOT EXISTS (SELECT FROM pg_user WHERE usename = '${ELECTRIC_DB_USER}') THEN
+                CREATE USER ${ELECTRIC_DB_USER} WITH REPLICATION PASSWORD '${ELECTRIC_DB_PASSWORD}';
+            END IF;
+        END
+        \\\$\\\$;
+
+        GRANT CONNECT ON DATABASE ${POSTGRES_DB:-surfsense} TO ${ELECTRIC_DB_USER};
+        GRANT USAGE ON SCHEMA public TO ${ELECTRIC_DB_USER};
+        GRANT SELECT ON ALL TABLES IN SCHEMA public TO ${ELECTRIC_DB_USER};
+        GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO ${ELECTRIC_DB_USER};
+        ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO ${ELECTRIC_DB_USER};
+        ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON SEQUENCES TO ${ELECTRIC_DB_USER};
+
+        -- Create the publication for Electric SQL (if not exists)
+        DO \\\$\\\$
+        BEGIN
+            IF NOT EXISTS (SELECT FROM pg_publication WHERE pubname = 'electric_publication_default') THEN
+                CREATE PUBLICATION electric_publication_default;
+            END IF;
+        END
+        \\\$\\\$;
+EOSQL"
+    echo "✅ Electric SQL user '${ELECTRIC_DB_USER}' created"
+    
     # Stop temporary PostgreSQL
     su - postgres -c "/usr/lib/postgresql/14/bin/pg_ctl -D /data/postgres stop"
     
@@ -107,18 +166,23 @@ echo "🔧 Applying runtime environment configuration..."
 NEXT_PUBLIC_FASTAPI_BACKEND_URL="${NEXT_PUBLIC_FASTAPI_BACKEND_URL:-http://localhost:8000}"
 NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE="${NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE:-LOCAL}"
 NEXT_PUBLIC_ETL_SERVICE="${NEXT_PUBLIC_ETL_SERVICE:-DOCLING}"
+NEXT_PUBLIC_ELECTRIC_URL="${NEXT_PUBLIC_ELECTRIC_URL:-http://localhost:5133}"
+NEXT_PUBLIC_ELECTRIC_AUTH_MODE="${NEXT_PUBLIC_ELECTRIC_AUTH_MODE:-insecure}"
 
 # Replace placeholders in all JS files
 find /app/frontend -type f \( -name "*.js" -o -name "*.json" \) -exec sed -i \
     -e "s|__NEXT_PUBLIC_FASTAPI_BACKEND_URL__|${NEXT_PUBLIC_FASTAPI_BACKEND_URL}|g" \
     -e "s|__NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE__|${NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE}|g" \
     -e "s|__NEXT_PUBLIC_ETL_SERVICE__|${NEXT_PUBLIC_ETL_SERVICE}|g" \
+    -e "s|__NEXT_PUBLIC_ELECTRIC_URL__|${NEXT_PUBLIC_ELECTRIC_URL}|g" \
+    -e "s|__NEXT_PUBLIC_ELECTRIC_AUTH_MODE__|${NEXT_PUBLIC_ELECTRIC_AUTH_MODE}|g" \
     {} +
 
 echo "✅ Environment configuration applied"
-echo "   Backend URL:  ${NEXT_PUBLIC_FASTAPI_BACKEND_URL}"
-echo "   Auth Type:    ${NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE}"
-echo "   ETL Service:  ${NEXT_PUBLIC_ETL_SERVICE}"
+echo "   Backend URL:   ${NEXT_PUBLIC_FASTAPI_BACKEND_URL}"
+echo "   Auth Type:     ${NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE}"
+echo "   ETL Service:   ${NEXT_PUBLIC_ETL_SERVICE}"
+echo "   Electric URL:  ${NEXT_PUBLIC_ELECTRIC_URL}"
 
 # ================================================
 # Run database migrations
@@ -161,6 +225,7 @@ echo "==========================================="
 echo "  Frontend URL:    http://localhost:3000"
 echo "  Backend API:     ${NEXT_PUBLIC_FASTAPI_BACKEND_URL}"
 echo "  API Docs:        ${NEXT_PUBLIC_FASTAPI_BACKEND_URL}/docs"
+echo "  Electric URL:    ${NEXT_PUBLIC_ELECTRIC_URL:-http://localhost:5133}"
 echo "  Auth Type:       ${NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE}"
 echo "  ETL Service:     ${NEXT_PUBLIC_ETL_SERVICE}"
 echo "  TTS Service:     ${TTS_SERVICE}"

scripts/docker/init-electric-user.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+# ============================================================================
+# Electric SQL User Initialization Script (docker-compose only)
+# ============================================================================
+# This script is ONLY used when running via docker-compose.
+#
+# How it works:
+# - docker-compose.yml mounts this script into the PostgreSQL container's
+#   /docker-entrypoint-initdb.d/ directory
+# - PostgreSQL automatically executes scripts in that directory on first
+#   container initialization
+#
+# For local PostgreSQL users (non-Docker), this script is NOT used.
+# Instead, the Electric user is created by Alembic migration 66
+# (66_add_notifications_table_and_electric_replication.py).
+#
+# Both approaches are idempotent (use IF NOT EXISTS), so running both
+# will not cause conflicts.
+# ============================================================================
+
+set -e
+
+# Use environment variables with defaults
+ELECTRIC_DB_USER="${ELECTRIC_DB_USER:-electric}"
+ELECTRIC_DB_PASSWORD="${ELECTRIC_DB_PASSWORD:-electric_password}"
+
+echo "Creating Electric SQL replication user: $ELECTRIC_DB_USER"
+
+psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-EOSQL
+    DO \$\$
+    BEGIN
+        IF NOT EXISTS (SELECT FROM pg_user WHERE usename = '$ELECTRIC_DB_USER') THEN
+            CREATE USER $ELECTRIC_DB_USER WITH REPLICATION PASSWORD '$ELECTRIC_DB_PASSWORD';
+        END IF;
+    END
+    \$\$;
+
+    GRANT CONNECT ON DATABASE $POSTGRES_DB TO $ELECTRIC_DB_USER;
+    GRANT CREATE ON DATABASE $POSTGRES_DB TO $ELECTRIC_DB_USER;
+    GRANT USAGE ON SCHEMA public TO $ELECTRIC_DB_USER;
+    GRANT SELECT ON ALL TABLES IN SCHEMA public TO $ELECTRIC_DB_USER;
+    GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO $ELECTRIC_DB_USER;
+    ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO $ELECTRIC_DB_USER;
+    ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON SEQUENCES TO $ELECTRIC_DB_USER;
+
+    -- Create the publication for Electric SQL (if not exists)
+    DO \$\$
+    BEGIN
+        IF NOT EXISTS (SELECT FROM pg_publication WHERE pubname = 'electric_publication_default') THEN
+            CREATE PUBLICATION electric_publication_default;
+        END IF;
+    END
+    \$\$;
+EOSQL
+
+echo "Electric SQL user '$ELECTRIC_DB_USER' and publication created successfully"

scripts/docker/init-postgres.sh

@@ -9,6 +9,10 @@ POSTGRES_USER=${POSTGRES_USER:-surfsense}
 POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-surfsense}
 POSTGRES_DB=${POSTGRES_DB:-surfsense}
 
+# Electric SQL user credentials (configurable)
+ELECTRIC_DB_USER=${ELECTRIC_DB_USER:-electric}
+ELECTRIC_DB_PASSWORD=${ELECTRIC_DB_PASSWORD:-electric_password}
+
 echo "Initializing PostgreSQL..."
 
 # Check if PostgreSQL is already initialized
@@ -23,8 +27,18 @@ fi
 # Configure PostgreSQL
 cat >> "$PGDATA/postgresql.conf" << EOF
 listen_addresses = '*'
-max_connections = 100
-shared_buffers = 128MB
+max_connections = 200
+shared_buffers = 256MB
+
+# Enable logical replication (required for Electric SQL)
+wal_level = logical
+max_replication_slots = 10
+max_wal_senders = 10
+
+# Performance settings
+checkpoint_timeout = 10min
+max_wal_size = 1GB
+min_wal_size = 80MB
 EOF
 
 cat >> "$PGDATA/pg_hba.conf" << EOF
@@ -45,6 +59,15 @@ CREATE USER $POSTGRES_USER WITH PASSWORD '$POSTGRES_PASSWORD' SUPERUSER;
 CREATE DATABASE $POSTGRES_DB OWNER $POSTGRES_USER;
 \c $POSTGRES_DB
 CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Create Electric SQL replication user
+CREATE USER $ELECTRIC_DB_USER WITH REPLICATION PASSWORD '$ELECTRIC_DB_PASSWORD';
+GRANT CONNECT ON DATABASE $POSTGRES_DB TO $ELECTRIC_DB_USER;
+GRANT USAGE ON SCHEMA public TO $ELECTRIC_DB_USER;
+GRANT SELECT ON ALL TABLES IN SCHEMA public TO $ELECTRIC_DB_USER;
+GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO $ELECTRIC_DB_USER;
+ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO $ELECTRIC_DB_USER;
+ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON SEQUENCES TO $ELECTRIC_DB_USER;
 EOF
 
 echo "PostgreSQL initialized successfully."

scripts/docker/postgresql.conf

@@ -0,0 +1,20 @@
+# PostgreSQL configuration for Electric SQL
+# This file is mounted into the PostgreSQL container
+
+listen_addresses = '*'
+max_connections = 200
+shared_buffers = 256MB
+
+# Enable logical replication (required for Electric SQL)
+wal_level = logical
+max_replication_slots = 10
+max_wal_senders = 10
+
+# Performance settings
+checkpoint_timeout = 10min
+max_wal_size = 1GB
+min_wal_size = 80MB
+
+# Logging (optional, for debugging)
+# log_statement = 'all'
+# log_replication_commands = on

scripts/docker/supervisor-allinone.conf

@@ -85,6 +85,20 @@ stderr_logfile=/dev/stderr
 stderr_logfile_maxbytes=0
 environment=PYTHONPATH="/app/backend"
 
+# Electric SQL (real-time sync)
+[program:electric]
+command=/app/electric-release/bin/entrypoint start
+autostart=true
+autorestart=true
+priority=25
+startsecs=10
+startretries=3
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+environment=DATABASE_URL="%(ENV_ELECTRIC_DATABASE_URL)s",ELECTRIC_INSECURE="%(ENV_ELECTRIC_INSECURE)s",ELECTRIC_WRITE_TO_PG_MODE="%(ENV_ELECTRIC_WRITE_TO_PG_MODE)s",RELEASE_COOKIE="surfsense_electric_cookie",PORT="%(ENV_ELECTRIC_PORT)s"
+
 # Frontend
 [program:frontend]
 command=node server.js
@@ -102,6 +116,6 @@ environment=NODE_ENV="production",PORT="3000",HOSTNAME="0.0.0.0"
 
 # Process Groups
 [group:surfsense]
-programs=postgresql,redis,backend,celery-worker,celery-beat,frontend
+programs=postgresql,redis,electric,backend,celery-worker,celery-beat,frontend
 priority=999
 

surfsense_backend/alembic/env.py

@@ -25,6 +25,13 @@ database_url = os.getenv("DATABASE_URL")
 if database_url:
     config.set_main_option("sqlalchemy.url", database_url)
 
+# Electric SQL user credentials - centralized configuration for migrations
+# These are used by migrations that set up Electric SQL replication
+config.set_main_option("electric_db_user", os.getenv("ELECTRIC_DB_USER", "electric"))
+config.set_main_option(
+    "electric_db_password", os.getenv("ELECTRIC_DB_PASSWORD", "electric_password")
+)
+
 # Interpret the config file for Python logging.
 # This line sets up loggers basically.
 if config.config_file_name is not None:

surfsense_backend/alembic/versions/66_add_notifications_table_and_electric_replication.py

@@ -0,0 +1,172 @@
+"""Add notifications table and Electric SQL replication
+
+Revision ID: 66
+Revises: 65
+
+Creates notifications table and sets up Electric SQL replication
+(user, publication, REPLICA IDENTITY FULL) for notifications,
+search_source_connectors, and documents tables.
+
+NOTE: Electric SQL user creation is idempotent (uses IF NOT EXISTS).
+- Docker deployments: user is pre-created by scripts/docker/init-electric-user.sh
+- Local PostgreSQL: user is created here during migration
+Both approaches are safe to run together without conflicts as this migraiton is idempotent
+"""
+
+from collections.abc import Sequence
+
+from alembic import context, op
+
+# Get Electric SQL user credentials from env.py configuration
+_config = context.config
+ELECTRIC_DB_USER = _config.get_main_option("electric_db_user", "electric")
+ELECTRIC_DB_PASSWORD = _config.get_main_option(
+    "electric_db_password", "electric_password"
+)
+
+# revision identifiers, used by Alembic.
+revision: str = "66"
+down_revision: str | None = "65"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Upgrade schema - add notifications table and Electric SQL replication."""
+    # Create notifications table
+    op.execute(
+        """
+        CREATE TABLE IF NOT EXISTS notifications (
+            id SERIAL PRIMARY KEY,
+            user_id UUID NOT NULL REFERENCES "user"(id) ON DELETE CASCADE,
+            search_space_id INTEGER REFERENCES searchspaces(id) ON DELETE CASCADE,
+            type VARCHAR(50) NOT NULL,
+            title VARCHAR(200) NOT NULL,
+            message TEXT NOT NULL,
+            read BOOLEAN NOT NULL DEFAULT FALSE,
+            metadata JSONB DEFAULT '{}',
+            created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+            updated_at TIMESTAMPTZ
+        );
+        """
+    )
+
+    # Create indexes (using IF NOT EXISTS for idempotency)
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS ix_notifications_user_id ON notifications (user_id);"
+    )
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS ix_notifications_read ON notifications (read);"
+    )
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS ix_notifications_created_at ON notifications (created_at);"
+    )
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS ix_notifications_user_read ON notifications (user_id, read);"
+    )
+
+    # =====================================================
+    # Electric SQL Setup - User and Publication
+    # =====================================================
+
+    # Create Electric SQL replication user if not exists
+    op.execute(
+        f"""
+        DO $$
+        BEGIN
+            IF NOT EXISTS (SELECT FROM pg_user WHERE usename = '{ELECTRIC_DB_USER}') THEN
+                CREATE USER {ELECTRIC_DB_USER} WITH REPLICATION PASSWORD '{ELECTRIC_DB_PASSWORD}';
+            END IF;
+        END
+        $$;
+        """
+    )
+
+    # Grant necessary permissions to electric user
+    op.execute(
+        f"""
+        DO $$
+        DECLARE
+            db_name TEXT := current_database();
+        BEGIN
+            EXECUTE format('GRANT CONNECT ON DATABASE %I TO {ELECTRIC_DB_USER}', db_name);
+        END
+        $$;
+        """
+    )
+    op.execute(f"GRANT USAGE ON SCHEMA public TO {ELECTRIC_DB_USER};")
+    op.execute(f"GRANT SELECT ON ALL TABLES IN SCHEMA public TO {ELECTRIC_DB_USER};")
+    op.execute(f"GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO {ELECTRIC_DB_USER};")
+    op.execute(
+        f"ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO {ELECTRIC_DB_USER};"
+    )
+    op.execute(
+        f"ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON SEQUENCES TO {ELECTRIC_DB_USER};"
+    )
+
+    # Create the publication if not exists
+    op.execute(
+        """
+        DO $$
+        BEGIN
+            IF NOT EXISTS (SELECT FROM pg_publication WHERE pubname = 'electric_publication_default') THEN
+                CREATE PUBLICATION electric_publication_default;
+            END IF;
+        END
+        $$;
+        """
+    )
+
+    # =====================================================
+    # Electric SQL Setup - Table Configuration
+    # =====================================================
+
+    # Set REPLICA IDENTITY FULL (required by Electric SQL for replication)
+    op.execute("ALTER TABLE notifications REPLICA IDENTITY FULL;")
+    op.execute("ALTER TABLE search_source_connectors REPLICA IDENTITY FULL;")
+    op.execute("ALTER TABLE documents REPLICA IDENTITY FULL;")
+
+    # Add tables to Electric SQL publication for replication
+    op.execute(
+        """
+        DO $$
+        BEGIN
+            -- Add notifications if not already added
+            IF NOT EXISTS (
+                SELECT 1 FROM pg_publication_tables 
+                WHERE pubname = 'electric_publication_default' 
+                AND tablename = 'notifications'
+            ) THEN
+                ALTER PUBLICATION electric_publication_default ADD TABLE notifications;
+            END IF;
+            
+            -- Add search_source_connectors if not already added
+            IF NOT EXISTS (
+                SELECT 1 FROM pg_publication_tables 
+                WHERE pubname = 'electric_publication_default' 
+                AND tablename = 'search_source_connectors'
+            ) THEN
+                ALTER PUBLICATION electric_publication_default ADD TABLE search_source_connectors;
+            END IF;
+            
+            -- Add documents if not already added
+            IF NOT EXISTS (
+                SELECT 1 FROM pg_publication_tables 
+                WHERE pubname = 'electric_publication_default' 
+                AND tablename = 'documents'
+            ) THEN
+                ALTER PUBLICATION electric_publication_default ADD TABLE documents;
+            END IF;
+        END
+        $$;
+        """
+    )
+
+
+def downgrade() -> None:
+    """Downgrade schema - remove notifications table."""
+    op.drop_index("ix_notifications_user_read", table_name="notifications")
+    op.drop_index("ix_notifications_created_at", table_name="notifications")
+    op.drop_index("ix_notifications_read", table_name="notifications")
+    op.drop_index("ix_notifications_user_id", table_name="notifications")
+    op.drop_table("notifications")

surfsense_backend/alembic/versions/67_add_pg_trgm_index_for_document_title_search.py

@@ -0,0 +1,76 @@
+"""Add pg_trgm indexes for efficient document title search
+
+Revision ID: 67
+Revises: 66
+
+Adds the pg_trgm extension and GIN trigram indexes on documents.title
+to enable efficient ILIKE searches with leading wildcards (e.g., '%search_term%').
+
+Indexes added:
+1. idx_documents_title_trgm - GIN trigram on title for ILIKE '%term%'
+2. idx_documents_search_space_id - B-tree on search_space_id for filtering
+3. idx_documents_search_space_updated - Composite for recent docs query (covering index)
+4. idx_surfsense_docs_title_trgm - GIN trigram on surfsense docs title
+
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "67"
+down_revision: str | None = "66"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Add pg_trgm extension and optimized indexes for document search."""
+
+    # Create pg_trgm extension if not exists
+    # This extension provides trigram-based text similarity functions and operators
+    op.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")
+
+    # 1. GIN trigram index on documents.title for ILIKE '%term%' searches
+    op.execute(
+        """
+        CREATE INDEX IF NOT EXISTS idx_documents_title_trgm 
+        ON documents USING gin (title gin_trgm_ops);
+        """
+    )
+
+    # 2. B-tree index on search_space_id for fast filtering
+    # (Every query filters by search_space_id first)
+    op.execute(
+        """
+        CREATE INDEX IF NOT EXISTS idx_documents_search_space_id 
+        ON documents (search_space_id);
+        """
+    )
+
+    # 3. Covering index for "recent documents" query (no search term)
+    # Includes id, title, document_type so PostgreSQL can do index-only scan
+    op.execute(
+        """
+        CREATE INDEX IF NOT EXISTS idx_documents_search_space_updated 
+        ON documents (search_space_id, updated_at DESC NULLS LAST)
+        INCLUDE (id, title, document_type);
+        """
+    )
+
+    # 4. GIN trigram index on surfsense_docs_documents.title
+    op.execute(
+        """
+        CREATE INDEX IF NOT EXISTS idx_surfsense_docs_title_trgm 
+        ON surfsense_docs_documents USING gin (title gin_trgm_ops);
+        """
+    )
+
+
+def downgrade() -> None:
+    """Remove all document search indexes (extension is left in place)."""
+    op.execute("DROP INDEX IF EXISTS idx_surfsense_docs_title_trgm;")
+    op.execute("DROP INDEX IF EXISTS idx_documents_search_space_updated;")
+    op.execute("DROP INDEX IF EXISTS idx_documents_search_space_id;")
+    op.execute("DROP INDEX IF EXISTS idx_documents_title_trgm;")

surfsense_backend/app/agents/new_chat/tools/mcp_client.py

@@ -4,6 +4,7 @@ This module provides a client for communicating with MCP servers via stdio trans
 It handles server lifecycle management, tool discovery, and tool execution.
 """
 
+import asyncio
 import logging
 import os
 from contextlib import asynccontextmanager
@@ -14,6 +15,11 @@ from mcp.client.stdio import StdioServerParameters, stdio_client
 
 logger = logging.getLogger(__name__)
 
+# Retry configuration
+MAX_RETRIES = 3
+RETRY_DELAY = 1.0  # seconds
+RETRY_BACKOFF = 2.0  # exponential backoff multiplier
+
 
 class MCPClient:
     """Client for communicating with an MCP server."""
@@ -35,44 +41,86 @@ class MCPClient:
         self.session: ClientSession | None = None
 
     @asynccontextmanager
-    async def connect(self):
+    async def connect(self, max_retries: int = MAX_RETRIES):
         """Connect to the MCP server and manage its lifecycle.
 
+        Args:
+            max_retries: Maximum number of connection retry attempts
+
         Yields:
             ClientSession: Active MCP session for making requests
 
+        Raises:
+            RuntimeError: If all connection attempts fail
+
         """
-        try:
-            # Merge env vars with current environment
-            server_env = os.environ.copy()
-            server_env.update(self.env)
+        last_error = None
+        delay = RETRY_DELAY
 
-            # Create server parameters with env
-            server_params = StdioServerParameters(
-                command=self.command, args=self.args, env=server_env
-            )
+        for attempt in range(max_retries):
+            try:
+                # Merge env vars with current environment
+                server_env = os.environ.copy()
+                server_env.update(self.env)
 
-            # Spawn server process and create session
-            # Note: Cannot combine these context managers because ClientSession
-            # needs the read/write streams from stdio_client
-            async with stdio_client(server=server_params) as (read, write):  # noqa: SIM117
-                async with ClientSession(read, write) as session:
-                    # Initialize the connection
-                    await session.initialize()
-                    self.session = session
-                    logger.info(
-                        "Connected to MCP server: %s %s",
-                        self.command,
-                        " ".join(self.args),
+                # Create server parameters with env
+                server_params = StdioServerParameters(
+                    command=self.command, args=self.args, env=server_env
+                )
+
+                # Spawn server process and create session
+                # Note: Cannot combine these context managers because ClientSession
+                # needs the read/write streams from stdio_client
+                async with stdio_client(server=server_params) as (read, write):  # noqa: SIM117
+                    async with ClientSession(read, write) as session:
+                        # Initialize the connection
+                        await session.initialize()
+                        self.session = session
+                        
+                        if attempt > 0:
+                            logger.info(
+                                "Connected to MCP server on attempt %d: %s %s",
+                                attempt + 1,
+                                self.command,
+                                " ".join(self.args),
+                            )
+                        else:
+                            logger.info(
+                                "Connected to MCP server: %s %s",
+                                self.command,
+                                " ".join(self.args),
+                            )
+                        yield session
+                        return  # Success, exit retry loop
+
+            except Exception as e:
+                last_error = e
+                if attempt < max_retries - 1:
+                    logger.warning(
+                        "MCP server connection failed (attempt %d/%d): %s. Retrying in %.1fs...",
+                        attempt + 1,
+                        max_retries,
+                        e,
+                        delay,
                     )
-                    yield session
+                    await asyncio.sleep(delay)
+                    delay *= RETRY_BACKOFF  # Exponential backoff
+                else:
+                    logger.error(
+                        "Failed to connect to MCP server after %d attempts: %s",
+                        max_retries,
+                        e,
+                        exc_info=True,
+                    )
+            finally:
+                self.session = None
 
-        except Exception as e:
-            logger.error("Failed to connect to MCP server: %s", e, exc_info=True)
-            raise
-        finally:
-            self.session = None
-            logger.info("Disconnected from MCP server: %s", self.command)
+        # All retries exhausted
+        error_msg = f"Failed to connect to MCP server '{self.command}' after {max_retries} attempts"
+        if last_error:
+            error_msg += f": {last_error}"
+        logger.error(error_msg)
+        raise RuntimeError(error_msg) from last_error
 
     async def list_tools(self) -> list[dict[str, Any]]:
         """List all tools available from the MCP server.

surfsense_backend/app/agents/new_chat/tools/mcp_tool.py

@@ -90,16 +90,22 @@ async def _create_mcp_tool_from_definition(
     input_model = _create_dynamic_input_model_from_schema(tool_name, input_schema)
 
     async def mcp_tool_call(**kwargs) -> str:
-        """Execute the MCP tool call via the client."""
+        """Execute the MCP tool call via the client with retry support."""
         logger.info(f"MCP tool '{tool_name}' called with params: {kwargs}")
 
         try:
-            # Connect to server and call tool
+            # Connect to server and call tool (connect has built-in retry logic)
             async with mcp_client.connect():
                 result = await mcp_client.call_tool(tool_name, kwargs)
                 return str(result)
+        except RuntimeError as e:
+            # Connection failures after all retries
+            error_msg = f"MCP tool '{tool_name}' connection failed after retries: {e!s}"
+            logger.error(error_msg)
+            return f"Error: {error_msg}"
         except Exception as e:
-            error_msg = f"MCP tool '{tool_name}' failed: {e!s}"
+            # Tool execution or other errors
+            error_msg = f"MCP tool '{tool_name}' execution failed: {e!s}"
             logger.exception(error_msg)
             return f"Error: {error_msg}"
 
@@ -146,17 +152,38 @@ async def load_mcp_tools(
         tools: list[StructuredTool] = []
         for connector in result.scalars():
             try:
-                # Extract server config
+                # Early validation: Extract and validate connector config
                 config = connector.config or {}
                 server_config = config.get("server_config", {})
-
-                command = server_config.get("command")
-                args = server_config.get("args", [])
-                env = server_config.get("env", {})
-
-                if not command:
+                
+                # Validate server_config exists and is a dict
+                if not server_config or not isinstance(server_config, dict):
                     logger.warning(
-                        f"MCP connector {connector.id} missing command, skipping"
+                        f"MCP connector {connector.id} (name: '{connector.name}') has invalid or missing server_config, skipping"
+                    )
+                    continue
+
+                # Validate required command field
+                command = server_config.get("command")
+                if not command or not isinstance(command, str):
+                    logger.warning(
+                        f"MCP connector {connector.id} (name: '{connector.name}') missing or invalid command field, skipping"
+                    )
+                    continue
+
+                # Validate args field (must be list if present)
+                args = server_config.get("args", [])
+                if not isinstance(args, list):
+                    logger.warning(
+                        f"MCP connector {connector.id} (name: '{connector.name}') has invalid args field (must be list), skipping"
+                    )
+                    continue
+
+                # Validate env field (must be dict if present)
+                env = server_config.get("env", {})
+                if not isinstance(env, dict):
+                    logger.warning(
+                        f"MCP connector {connector.id} (name: '{connector.name}') has invalid env field (must be dict), skipping"
                     )
                     continue
 
@@ -172,22 +199,21 @@ async def load_mcp_tools(
                         f"'{command}' (connector {connector.id})"
                     )
 
-                    # Create LangChain tools from definitions
-                    for tool_def in tool_definitions:
-                        try:
-                            tool = await _create_mcp_tool_from_definition(
-                                tool_def, mcp_client
-                            )
-                            tools.append(tool)
-                        except Exception as e:
-                            logger.exception(
-                                f"Failed to create tool '{tool_def.get('name')}' "
-                                f"from connector {connector.id}: {e!s}",
-                            )
-
+                # Create LangChain tools from definitions
+                for tool_def in tool_definitions:
+                    try:
+                        tool = await _create_mcp_tool_from_definition(
+                            tool_def, mcp_client
+                        )
+                        tools.append(tool)
+                    except Exception as e:
+                        logger.exception(
+                            f"Failed to create tool '{tool_def.get('name')}' "
+                            f"from connector {connector.id}: {e!s}"
+                        )
             except Exception as e:
                 logger.exception(
-                    f"Failed to load tools from MCP connector {connector.id}: {e!s}",
+                    f"Failed to load tools from MCP connector {connector.id}: {e!s}"
                 )
 
         logger.info(f"Loaded {len(tools)} MCP tools for search space {search_space_id}")

surfsense_backend/app/connectors/google_drive/change_tracker.py

@@ -58,7 +58,7 @@ async def get_changes(
         params = {
             "pageToken": page_token,
             "pageSize": 100,
-            "fields": "nextPageToken, newStartPageToken, changes(fileId, removed, file(id, name, mimeType, modifiedTime, size, webViewLink, parents, trashed))",
+            "fields": "nextPageToken, newStartPageToken, changes(fileId, removed, file(id, name, mimeType, modifiedTime, md5Checksum, size, webViewLink, parents, trashed))",
             "supportsAllDrives": True,
             "includeItemsFromAllDrives": True,
         }

surfsense_backend/app/connectors/google_drive/client.py

@@ -47,7 +47,7 @@ class GoogleDriveClient:
     async def list_files(
         self,
         query: str = "",
-        fields: str = "nextPageToken, files(id, name, mimeType, modifiedTime, size, webViewLink, parents, owners, createdTime, description)",
+        fields: str = "nextPageToken, files(id, name, mimeType, modifiedTime, md5Checksum, size, webViewLink, parents, owners, createdTime, description)",
         page_size: int = 100,
         page_token: str | None = None,
     ) -> tuple[list[dict[str, Any]], str | None, str | None]:

surfsense_backend/app/connectors/google_drive/content_extractor.py

@@ -102,6 +102,8 @@ async def download_and_process_file(
             connector_info["metadata"]["file_size"] = file["size"]
         if "webViewLink" in file:
             connector_info["metadata"]["web_view_link"] = file["webViewLink"]
+        if "md5Checksum" in file:
+            connector_info["metadata"]["md5_checksum"] = file["md5Checksum"]
 
         if is_google_workspace_file(mime_type):
             connector_info["metadata"]["exported_as"] = "pdf"

surfsense_backend/app/connectors/google_drive/folder_manager.py

@@ -157,7 +157,7 @@ async def get_file_by_id(
     try:
         file, error = await client.get_file_metadata(
             file_id,
-            fields="id, name, mimeType, parents, createdTime, modifiedTime, size, webViewLink, iconLink",
+            fields="id, name, mimeType, parents, createdTime, modifiedTime, md5Checksum, size, webViewLink, iconLink",
         )
 
         if error:
@@ -228,7 +228,7 @@ async def list_folder_contents(
         while True:
             items, next_token, error = await client.list_files(
                 query=query,
-                fields="files(id, name, mimeType, parents, createdTime, modifiedTime, size, webViewLink, iconLink)",
+                fields="files(id, name, mimeType, parents, createdTime, modifiedTime, md5Checksum, size, webViewLink, iconLink)",
                 page_size=1000,  # Max allowed by Google Drive API
                 page_token=page_token,
             )

surfsense_backend/app/db.py

@@ -667,6 +667,12 @@ class SearchSpace(BaseModel, TimestampMixin):
         order_by="Log.id",
         cascade="all, delete-orphan",
     )
+    notifications = relationship(
+        "Notification",
+        back_populates="search_space",
+        order_by="Notification.created_at.desc()",
+        cascade="all, delete-orphan",
+    )
     search_source_connectors = relationship(
         "SearchSourceConnector",
         back_populates="search_space",
@@ -805,6 +811,39 @@ class Log(BaseModel, TimestampMixin):
     search_space = relationship("SearchSpace", back_populates="logs")
 
 
+class Notification(BaseModel, TimestampMixin):
+    __tablename__ = "notifications"
+
+    user_id = Column(
+        UUID(as_uuid=True),
+        ForeignKey("user.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    search_space_id = Column(
+        Integer, ForeignKey("searchspaces.id", ondelete="CASCADE"), nullable=True
+    )
+    type = Column(
+        String(50), nullable=False
+    )  # 'connector_indexing', 'document_processing', etc.
+    title = Column(String(200), nullable=False)
+    message = Column(Text, nullable=False)
+    read = Column(
+        Boolean, nullable=False, default=False, server_default=text("false"), index=True
+    )
+    notification_metadata = Column("metadata", JSONB, nullable=True, default={})
+    updated_at = Column(
+        TIMESTAMP(timezone=True),
+        nullable=True,
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
+        index=True,
+    )
+
+    user = relationship("User", back_populates="notifications")
+    search_space = relationship("SearchSpace", back_populates="notifications")
+
+
 class SearchSpaceRole(BaseModel, TimestampMixin):
     """
     Custom roles that can be defined per search space.
@@ -949,6 +988,12 @@ if config.AUTH_TYPE == "GOOGLE":
             "OAuthAccount", lazy="joined"
         )
         search_spaces = relationship("SearchSpace", back_populates="user")
+        notifications = relationship(
+            "Notification",
+            back_populates="user",
+            order_by="Notification.created_at.desc()",
+            cascade="all, delete-orphan",
+        )
 
         # RBAC relationships
         search_space_memberships = relationship(
@@ -986,6 +1031,12 @@ else:
 
     class User(SQLAlchemyBaseUserTableUUID, Base):
         search_spaces = relationship("SearchSpace", back_populates="user")
+        notifications = relationship(
+            "Notification",
+            back_populates="user",
+            order_by="Notification.created_at.desc()",
+            cascade="all, delete-orphan",
+        )
 
         # RBAC relationships
         search_space_memberships = relationship(
@@ -1049,11 +1100,36 @@ async def setup_indexes():
                 "CREATE INDEX IF NOT EXISTS chucks_search_index ON chunks USING gin (to_tsvector('english', content))"
             )
         )
+        # pg_trgm indexes for efficient ILIKE '%term%' searches on titles
+        # Critical for document mention picker (@mentions) to scale
+        await conn.execute(
+            text(
+                "CREATE INDEX IF NOT EXISTS idx_documents_title_trgm ON documents USING gin (title gin_trgm_ops)"
+            )
+        )
+        # B-tree index on search_space_id for fast filtering
+        await conn.execute(
+            text(
+                "CREATE INDEX IF NOT EXISTS idx_documents_search_space_id ON documents (search_space_id)"
+            )
+        )
+        # Covering index for "recent documents" query - enables index-only scan
+        await conn.execute(
+            text(
+                "CREATE INDEX IF NOT EXISTS idx_documents_search_space_updated ON documents (search_space_id, updated_at DESC NULLS LAST) INCLUDE (id, title, document_type)"
+            )
+        )
+        await conn.execute(
+            text(
+                "CREATE INDEX IF NOT EXISTS idx_surfsense_docs_title_trgm ON surfsense_docs_documents USING gin (title gin_trgm_ops)"
+            )
+        )
 
 
 async def create_db_and_tables():
     async with engine.begin() as conn:
         await conn.execute(text("CREATE EXTENSION IF NOT EXISTS vector"))
+        await conn.execute(text("CREATE EXTENSION IF NOT EXISTS pg_trgm"))
         await conn.run_sync(Base.metadata.create_all)
     await setup_indexes()
 

surfsense_backend/app/routes/__init__.py

@@ -26,6 +26,7 @@ from .luma_add_connector_route import router as luma_add_connector_router
 from .new_chat_routes import router as new_chat_router
 from .new_llm_config_routes import router as new_llm_config_router
 from .notes_routes import router as notes_router
+from .notifications_routes import router as notifications_router
 from .notion_add_connector_route import router as notion_add_connector_router
 from .podcasts_routes import router as podcasts_router
 from .rbac_routes import router as rbac_router
@@ -63,3 +64,4 @@ router.include_router(new_llm_config_router)  # LLM configs with prompt configur
 router.include_router(logs_router)
 router.include_router(circleback_webhook_router)  # Circleback meeting webhooks
 router.include_router(surfsense_docs_router)  # Surfsense documentation for citations
+router.include_router(notifications_router)  # Notifications with Electric SQL sync

surfsense_backend/app/routes/documents_routes.py

@@ -19,6 +19,8 @@ from app.db import (
 from app.schemas import (
     DocumentRead,
     DocumentsCreate,
+    DocumentTitleRead,
+    DocumentTitleSearchResponse,
     DocumentUpdate,
     DocumentWithChunksRead,
     PaginatedResponse,
@@ -429,6 +431,112 @@ async def search_documents(
         ) from e
 
 
+@router.get("/documents/search/titles", response_model=DocumentTitleSearchResponse)
+async def search_document_titles(
+    search_space_id: int,
+    title: str = "",
+    page: int = 0,
+    page_size: int = 20,
+    session: AsyncSession = Depends(get_async_session),
+    user: User = Depends(current_active_user),
+):
+    """
+    Lightweight document title search optimized for mention picker (@mentions).
+
+    Returns only id, title, and document_type - no content or metadata.
+    Uses pg_trgm fuzzy search with similarity scoring for typo tolerance.
+    Results are ordered by relevance using trigram similarity scores.
+
+    Args:
+        search_space_id: The search space to search in. Required.
+        title: Search query (case-insensitive). If empty or < 2 chars, returns recent documents.
+        page: Zero-based page index. Default: 0.
+        page_size: Number of items per page. Default: 20.
+        session: Database session (injected).
+        user: Current authenticated user (injected).
+
+    Returns:
+        DocumentTitleSearchResponse: Lightweight list with has_more flag (no total count).
+    """
+    from sqlalchemy import desc, func, or_
+
+    try:
+        # Check permission for the search space
+        await check_permission(
+            session,
+            user,
+            search_space_id,
+            Permission.DOCUMENTS_READ.value,
+            "You don't have permission to read documents in this search space",
+        )
+
+        # Base query - only select lightweight fields
+        query = select(
+            Document.id,
+            Document.title,
+            Document.document_type,
+        ).filter(Document.search_space_id == search_space_id)
+
+        # If query is too short, return recent documents ordered by updated_at
+        if len(title.strip()) < 2:
+            query = query.order_by(Document.updated_at.desc().nullslast())
+        else:
+            # Fuzzy search using pg_trgm similarity + ILIKE fallback
+            search_term = title.strip()
+
+            # Similarity threshold for fuzzy matching (0.3 = ~30% trigram overlap)
+            # Lower values = more fuzzy, higher values = stricter matching
+            similarity_threshold = 0.3
+
+            # Match documents that either:
+            # 1. Have high trigram similarity (fuzzy match - handles typos)
+            # 2. Contain the exact substring (ILIKE - handles partial matches)
+            query = query.filter(
+                or_(
+                    func.similarity(Document.title, search_term) > similarity_threshold,
+                    Document.title.ilike(f"%{search_term}%"),
+                )
+            )
+
+            # Order by similarity score (descending) for best relevance ranking
+            # Higher similarity = better match = appears first
+            query = query.order_by(
+                desc(func.similarity(Document.title, search_term)),
+                Document.title,  # Alphabetical tiebreaker
+            )
+
+        # Fetch page_size + 1 to determine has_more without COUNT query
+        offset = page * page_size
+        result = await session.execute(query.offset(offset).limit(page_size + 1))
+        rows = result.all()
+
+        # Check if there are more results
+        has_more = len(rows) > page_size
+        items = rows[:page_size]  # Only return requested page_size
+
+        # Convert to response format
+        api_documents = [
+            DocumentTitleRead(
+                id=row.id,
+                title=row.title,
+                document_type=row.document_type,
+            )
+            for row in items
+        ]
+
+        return DocumentTitleSearchResponse(
+            items=api_documents,
+            has_more=has_more,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to search document titles: {e!s}"
+        ) from e
+
+
 @router.get("/documents/type-counts")
 async def get_document_type_counts(
     search_space_id: int | None = None,

surfsense_backend/app/routes/notifications_routes.py

@@ -0,0 +1,102 @@
+"""
+Notifications API routes.
+These endpoints allow marking notifications as read.
+Electric SQL automatically syncs the changes to all connected clients.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db import Notification, User, get_async_session
+from app.users import current_active_user
+
+router = APIRouter(prefix="/notifications", tags=["notifications"])
+
+
+class MarkReadResponse(BaseModel):
+    """Response for mark as read operations."""
+
+    success: bool
+    message: str
+
+
+class MarkAllReadResponse(BaseModel):
+    """Response for mark all as read operation."""
+
+    success: bool
+    message: str
+    updated_count: int
+
+
+@router.patch("/{notification_id}/read", response_model=MarkReadResponse)
+async def mark_notification_as_read(
+    notification_id: int,
+    user: User = Depends(current_active_user),
+    session: AsyncSession = Depends(get_async_session),
+) -> MarkReadResponse:
+    """
+    Mark a single notification as read.
+
+    Electric SQL will automatically sync this change to all connected clients.
+    """
+    # Verify the notification belongs to the user
+    result = await session.execute(
+        select(Notification).where(
+            Notification.id == notification_id,
+            Notification.user_id == user.id,
+        )
+    )
+    notification = result.scalar_one_or_none()
+
+    if not notification:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Notification not found",
+        )
+
+    if notification.read:
+        return MarkReadResponse(
+            success=True,
+            message="Notification already marked as read",
+        )
+
+    # Update the notification
+    notification.read = True
+    await session.commit()
+
+    return MarkReadResponse(
+        success=True,
+        message="Notification marked as read",
+    )
+
+
+@router.patch("/read-all", response_model=MarkAllReadResponse)
+async def mark_all_notifications_as_read(
+    user: User = Depends(current_active_user),
+    session: AsyncSession = Depends(get_async_session),
+) -> MarkAllReadResponse:
+    """
+    Mark all notifications as read for the current user.
+
+    Electric SQL will automatically sync these changes to all connected clients.
+    """
+    # Update all unread notifications for the user
+    result = await session.execute(
+        update(Notification)
+        .where(
+            Notification.user_id == user.id,
+            Notification.read == False,  # noqa: E712
+        )
+        .values(read=True)
+    )
+    await session.commit()
+
+    updated_count = result.rowcount
+
+    return MarkAllReadResponse(
+        success=True,
+        message=f"Marked {updated_count} notification(s) as read",
+        updated_count=updated_count,
+    )

surfsense_backend/app/schemas/__init__.py

@@ -4,13 +4,15 @@ from .documents import (
     DocumentBase,
     DocumentRead,
     DocumentsCreate,
+    DocumentTitleRead,
+    DocumentTitleSearchResponse,
     DocumentUpdate,
     DocumentWithChunksRead,
     ExtensionDocumentContent,
     ExtensionDocumentMetadata,
     PaginatedResponse,
 )
-from .google_drive import DriveItem, GoogleDriveIndexRequest
+from .google_drive import DriveItem, GoogleDriveIndexingOptions, GoogleDriveIndexRequest
 from .logs import LogBase, LogCreate, LogFilter, LogRead, LogUpdate
 from .new_chat import (
     ChatMessage,
@@ -85,6 +87,8 @@ __all__ = [
     # Document schemas
     "DocumentBase",
     "DocumentRead",
+    "DocumentTitleRead",
+    "DocumentTitleSearchResponse",
     "DocumentUpdate",
     "DocumentWithChunksRead",
     "DocumentsCreate",
@@ -94,6 +98,7 @@ __all__ = [
     "ExtensionDocumentMetadata",
     "GlobalNewLLMConfigRead",
     "GoogleDriveIndexRequest",
+    "GoogleDriveIndexingOptions",
     # Base schemas
     "IDModel",
     # RBAC schemas

surfsense_backend/app/schemas/documents.py

@@ -67,3 +67,20 @@ class PaginatedResponse[T](BaseModel):
     page: int
     page_size: int
     has_more: bool
+
+
+class DocumentTitleRead(BaseModel):
+    """Lightweight document response for mention picker - only essential fields."""
+
+    id: int
+    title: str
+    document_type: DocumentType
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class DocumentTitleSearchResponse(BaseModel):
+    """Response for document title search - optimized for typeahead."""
+
+    items: list[DocumentTitleRead]
+    has_more: bool

surfsense_backend/app/schemas/google_drive.py

@@ -10,6 +10,25 @@ class DriveItem(BaseModel):
     name: str = Field(..., description="Item display name")
 
 
+class GoogleDriveIndexingOptions(BaseModel):
+    """Indexing options for Google Drive connector."""
+
+    max_files_per_folder: int = Field(
+        default=100,
+        ge=1,
+        le=1000,
+        description="Maximum number of files to index from each folder (1-1000)",
+    )
+    incremental_sync: bool = Field(
+        default=True,
+        description="Only sync changes since last index (faster). Disable for a full re-index.",
+    )
+    include_subfolders: bool = Field(
+        default=True,
+        description="Recursively index files in subfolders of selected folders",
+    )
+
+
 class GoogleDriveIndexRequest(BaseModel):
     """Request body for indexing Google Drive content."""
 
@@ -19,6 +38,10 @@ class GoogleDriveIndexRequest(BaseModel):
     files: list[DriveItem] = Field(
         default_factory=list, description="List of specific files to index"
     )
+    indexing_options: GoogleDriveIndexingOptions = Field(
+        default_factory=GoogleDriveIndexingOptions,
+        description="Indexing configuration options",
+    )
 
     def has_items(self) -> bool:
         """Check if any items are selected."""

surfsense_backend/app/schemas/search_source_connector.py

@@ -95,7 +95,7 @@ class MCPConnectorCreate(BaseModel):
     """Schema for creating an MCP connector."""
 
     name: str
-    server_config: MCPServerConfig
+    server_config: MCPServerConfig  # Single MCP server configuration
 
 
 class MCPConnectorUpdate(BaseModel):
@@ -106,7 +106,7 @@ class MCPConnectorUpdate(BaseModel):
 
 
 class MCPConnectorRead(BaseModel):
-    """Schema for reading an MCP connector with server config."""
+    """Schema for reading an MCP connector with server configs."""
 
     id: int
     name: str
@@ -123,7 +123,8 @@ class MCPConnectorRead(BaseModel):
     def from_connector(cls, connector: SearchSourceConnectorRead) -> "MCPConnectorRead":
         """Convert from base SearchSourceConnectorRead."""
         config = connector.config or {}
-        server_config = MCPServerConfig(**config.get("server_config", {}))
+        server_config_data = config.get("server_config", {})
+        server_config = MCPServerConfig(**server_config_data)
 
         return cls(
             id=connector.id,

surfsense_backend/app/services/notification_service.py

@@ -0,0 +1,664 @@
+"""Service for creating and managing notifications with Electric SQL sync."""
+
+import logging
+from datetime import UTC, datetime
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm.attributes import flag_modified
+
+from app.db import Notification
+
+logger = logging.getLogger(__name__)
+
+
+class BaseNotificationHandler:
+    """Base class for notification handlers - provides common functionality."""
+
+    def __init__(self, notification_type: str):
+        """
+        Initialize the notification handler.
+
+        Args:
+            notification_type: Type of notification (e.g., 'connector_indexing', 'document_processing')
+        """
+        self.notification_type = notification_type
+
+    async def find_notification_by_operation(
+        self,
+        session: AsyncSession,
+        user_id: UUID,
+        operation_id: str,
+        search_space_id: int | None = None,
+    ) -> Notification | None:
+        """
+        Find an existing notification by operation ID.
+
+        Args:
+            session: Database session
+            user_id: User ID
+            operation_id: Unique operation identifier
+            search_space_id: Optional search space ID
+
+        Returns:
+            Notification if found, None otherwise
+        """
+        query = select(Notification).where(
+            Notification.user_id == user_id,
+            Notification.type == self.notification_type,
+            Notification.notification_metadata["operation_id"].astext == operation_id,
+        )
+        if search_space_id is not None:
+            query = query.where(Notification.search_space_id == search_space_id)
+
+        result = await session.execute(query)
+        return result.scalar_one_or_none()
+
+    async def find_or_create_notification(
+        self,
+        session: AsyncSession,
+        user_id: UUID,
+        operation_id: str,
+        title: str,
+        message: str,
+        search_space_id: int | None = None,
+        initial_metadata: dict[str, Any] | None = None,
+    ) -> Notification:
+        """
+        Find an existing notification or create a new one.
+
+        Args:
+            session: Database session
+            user_id: User ID
+            operation_id: Unique operation identifier
+            title: Notification title
+            message: Notification message
+            search_space_id: Optional search space ID
+            initial_metadata: Initial metadata dictionary
+
+        Returns:
+            Notification: The found or created notification
+        """
+        # Try to find existing notification
+        notification = await self.find_notification_by_operation(
+            session, user_id, operation_id, search_space_id
+        )
+
+        if notification:
+            # Update existing notification
+            notification.title = title
+            notification.message = message
+            if initial_metadata:
+                notification.notification_metadata = {
+                    **notification.notification_metadata,
+                    **initial_metadata,
+                }
+                # Mark JSONB column as modified so SQLAlchemy detects the change
+                flag_modified(notification, "notification_metadata")
+            await session.commit()
+            await session.refresh(notification)
+            logger.info(
+                f"Updated notification {notification.id} for operation {operation_id}"
+            )
+            return notification
+
+        # Create new notification
+        metadata = initial_metadata or {}
+        metadata["operation_id"] = operation_id
+        metadata["status"] = "in_progress"
+        metadata["started_at"] = datetime.now(UTC).isoformat()
+
+        notification = Notification(
+            user_id=user_id,
+            search_space_id=search_space_id,
+            type=self.notification_type,
+            title=title,
+            message=message,
+            notification_metadata=metadata,
+        )
+        session.add(notification)
+        await session.commit()
+        await session.refresh(notification)
+        logger.info(
+            f"Created notification {notification.id} for operation {operation_id}"
+        )
+        return notification
+
+    async def update_notification(
+        self,
+        session: AsyncSession,
+        notification: Notification,
+        title: str | None = None,
+        message: str | None = None,
+        status: str | None = None,
+        metadata_updates: dict[str, Any] | None = None,
+    ) -> Notification:
+        """
+        Update an existing notification.
+
+        Args:
+            session: Database session
+            notification: Notification to update
+            title: New title (optional)
+            message: New message (optional)
+            status: New status (optional)
+            metadata_updates: Additional metadata to merge (optional)
+
+        Returns:
+            Updated notification
+        """
+        if title is not None:
+            notification.title = title
+        if message is not None:
+            notification.message = message
+
+        if status is not None:
+            notification.notification_metadata["status"] = status
+            if status in ("completed", "failed"):
+                notification.notification_metadata["completed_at"] = datetime.now(
+                    UTC
+                ).isoformat()
+            # Mark JSONB column as modified so SQLAlchemy detects the change
+            flag_modified(notification, "notification_metadata")
+
+        if metadata_updates:
+            notification.notification_metadata = {
+                **notification.notification_metadata,
+                **metadata_updates,
+            }
+            # Mark JSONB column as modified
+            flag_modified(notification, "notification_metadata")
+
+        await session.commit()
+        await session.refresh(notification)
+        logger.info(f"Updated notification {notification.id}")
+        return notification
+
+
+class ConnectorIndexingNotificationHandler(BaseNotificationHandler):
+    """Handler for connector indexing notifications."""
+
+    def __init__(self):
+        super().__init__("connector_indexing")
+
+    def _generate_operation_id(
+        self,
+        connector_id: int,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> str:
+        """
+        Generate a unique operation ID for a connector indexing operation.
+
+        Args:
+            connector_id: Connector ID
+            start_date: Start date (optional)
+            end_date: End date (optional)
+
+        Returns:
+            Unique operation ID string
+        """
+        timestamp = datetime.now(UTC).strftime("%Y%m%d_%H%M%S")
+        date_range = ""
+        if start_date or end_date:
+            date_range = f"_{start_date or 'none'}_{end_date or 'none'}"
+        return f"connector_{connector_id}_{timestamp}{date_range}"
+
+    def _generate_google_drive_operation_id(
+        self, connector_id: int, folder_count: int, file_count: int
+    ) -> str:
+        """
+        Generate a unique operation ID for a Google Drive indexing operation.
+
+        Args:
+            connector_id: Connector ID
+            folder_count: Number of folders to index
+            file_count: Number of files to index
+
+        Returns:
+            Unique operation ID string
+        """
+        timestamp = datetime.now(UTC).strftime("%Y%m%d_%H%M%S")
+        items_info = f"_{folder_count}f_{file_count}files"
+        return f"drive_{connector_id}_{timestamp}{items_info}"
+
+    async def notify_indexing_started(
+        self,
+        session: AsyncSession,
+        user_id: UUID,
+        connector_id: int,
+        connector_name: str,
+        connector_type: str,
+        search_space_id: int,
+        start_date: str | None = None,
+        end_date: str | None = None,
+    ) -> Notification:
+        """
+        Create or update notification when connector indexing starts.
+
+        Args:
+            session: Database session
+            user_id: User ID
+            connector_id: Connector ID
+            connector_name: Connector name
+            connector_type: Connector type
+            search_space_id: Search space ID
+            start_date: Start date for indexing
+            end_date: End date for indexing
+
+        Returns:
+            Notification: The created or updated notification
+        """
+        operation_id = self._generate_operation_id(connector_id, start_date, end_date)
+        title = f"Syncing: {connector_name}"
+        message = "Connecting to your account"
+
+        metadata = {
+            "connector_id": connector_id,
+            "connector_name": connector_name,
+            "connector_type": connector_type,
+            "start_date": start_date,
+            "end_date": end_date,
+            "indexed_count": 0,
+            "sync_stage": "connecting",
+        }
+
+        return await self.find_or_create_notification(
+            session=session,
+            user_id=user_id,
+            operation_id=operation_id,
+            title=title,
+            message=message,
+            search_space_id=search_space_id,
+            initial_metadata=metadata,
+        )
+
+    async def notify_indexing_progress(
+        self,
+        session: AsyncSession,
+        notification: Notification,
+        indexed_count: int,
+        total_count: int | None = None,
+        stage: str | None = None,
+        stage_message: str | None = None,
+    ) -> Notification:
+        """
+        Update notification with indexing progress.
+
+        Args:
+            session: Database session
+            notification: Notification to update
+            indexed_count: Number of items indexed so far
+            total_count: Total number of items (optional)
+            stage: Current sync stage (fetching, processing, storing) (optional)
+            stage_message: Optional custom message for the stage
+
+        Returns:
+            Updated notification
+        """
+        # User-friendly stage messages (clean, no ellipsis - spinner shows activity)
+        stage_messages = {
+            "connecting": "Connecting to your account",
+            "fetching": "Fetching your content",
+            "processing": "Preparing for search",
+            "storing": "Almost done",
+        }
+
+        # Use stage-based message if stage provided, otherwise fallback
+        if stage or stage_message:
+            progress_msg = stage_message or stage_messages.get(stage, "Processing")
+        else:
+            # Fallback for backward compatibility
+            progress_msg = "Fetching your content"
+
+        metadata_updates = {"indexed_count": indexed_count}
+        if total_count is not None:
+            metadata_updates["total_count"] = total_count
+            progress_percent = int((indexed_count / total_count) * 100)
+            metadata_updates["progress_percent"] = progress_percent
+        if stage:
+            metadata_updates["sync_stage"] = stage
+
+        return await self.update_notification(
+            session=session,
+            notification=notification,
+            message=progress_msg,
+            status="in_progress",
+            metadata_updates=metadata_updates,
+        )
+
+    async def notify_indexing_completed(
+        self,
+        session: AsyncSession,
+        notification: Notification,
+        indexed_count: int,
+        error_message: str | None = None,
+    ) -> Notification:
+        """
+        Update notification when connector indexing completes.
+
+        Args:
+            session: Database session
+            notification: Notification to update
+            indexed_count: Total number of items indexed
+            error_message: Error message if indexing failed (optional)
+
+        Returns:
+            Updated notification
+        """
+        connector_name = notification.notification_metadata.get(
+            "connector_name", "Connector"
+        )
+
+        if error_message:
+            title = f"Failed: {connector_name}"
+            message = f"Sync failed: {error_message}"
+            status = "failed"
+        else:
+            title = f"Ready: {connector_name}"
+            if indexed_count == 0:
+                message = "Already up to date! No new items to sync."
+            else:
+                item_text = "item" if indexed_count == 1 else "items"
+                message = f"Now searchable! {indexed_count} {item_text} synced."
+            status = "completed"
+
+        metadata_updates = {
+            "indexed_count": indexed_count,
+            "sync_stage": "completed" if not error_message else "failed",
+            "error_message": error_message,
+        }
+
+        return await self.update_notification(
+            session=session,
+            notification=notification,
+            title=title,
+            message=message,
+            status=status,
+            metadata_updates=metadata_updates,
+        )
+
+    async def notify_google_drive_indexing_started(
+        self,
+        session: AsyncSession,
+        user_id: UUID,
+        connector_id: int,
+        connector_name: str,
+        connector_type: str,
+        search_space_id: int,
+        folder_count: int,
+        file_count: int,
+        folder_names: list[str] | None = None,
+        file_names: list[str] | None = None,
+    ) -> Notification:
+        """
+        Create or update notification when Google Drive indexing starts.
+
+        Args:
+            session: Database session
+            user_id: User ID
+            connector_id: Connector ID
+            connector_name: Connector name
+            connector_type: Connector type
+            search_space_id: Search space ID
+            folder_count: Number of folders to index
+            file_count: Number of files to index
+            folder_names: List of folder names (optional)
+            file_names: List of file names (optional)
+
+        Returns:
+            Notification: The created or updated notification
+        """
+        operation_id = self._generate_google_drive_operation_id(
+            connector_id, folder_count, file_count
+        )
+        title = f"Syncing: {connector_name}"
+        message = "Preparing your files"
+
+        metadata = {
+            "connector_id": connector_id,
+            "connector_name": connector_name,
+            "connector_type": connector_type,
+            "folder_count": folder_count,
+            "file_count": file_count,
+            "indexed_count": 0,
+            "sync_stage": "connecting",
+        }
+
+        if folder_names:
+            metadata["folder_names"] = folder_names
+        if file_names:
+            metadata["file_names"] = file_names
+
+        return await self.find_or_create_notification(
+            session=session,
+            user_id=user_id,
+            operation_id=operation_id,
+            title=title,
+            message=message,
+            search_space_id=search_space_id,
+            initial_metadata=metadata,
+        )
+
+
+class DocumentProcessingNotificationHandler(BaseNotificationHandler):
+    """Handler for document processing notifications."""
+
+    def __init__(self):
+        super().__init__("document_processing")
+
+    def _generate_operation_id(
+        self, document_type: str, filename: str, search_space_id: int
+    ) -> str:
+        """
+        Generate a unique operation ID for a document processing operation.
+
+        Args:
+            document_type: Type of document (FILE, YOUTUBE_VIDEO, CRAWLED_URL, etc.)
+            filename: Name of the file/document
+            search_space_id: Search space ID
+
+        Returns:
+            Unique operation ID string
+        """
+        timestamp = datetime.now(UTC).strftime("%Y%m%d_%H%M%S_%f")
+        # Create a short hash of filename to ensure uniqueness
+        import hashlib
+
+        filename_hash = hashlib.md5(filename.encode()).hexdigest()[:8]
+        return f"doc_{document_type}_{search_space_id}_{timestamp}_{filename_hash}"
+
+    async def notify_processing_started(
+        self,
+        session: AsyncSession,
+        user_id: UUID,
+        document_type: str,
+        document_name: str,
+        search_space_id: int,
+        file_size: int | None = None,
+    ) -> Notification:
+        """
+        Create notification when document processing starts.
+
+        Args:
+            session: Database session
+            user_id: User ID
+            document_type: Type of document (FILE, YOUTUBE_VIDEO, CRAWLED_URL, etc.)
+            document_name: Name/title of the document
+            search_space_id: Search space ID
+            file_size: Size of file in bytes (optional)
+
+        Returns:
+            Notification: The created notification
+        """
+        operation_id = self._generate_operation_id(
+            document_type, document_name, search_space_id
+        )
+        title = f"Processing: {document_name}"
+        message = "Waiting in queue"
+
+        metadata = {
+            "document_type": document_type,
+            "document_name": document_name,
+            "processing_stage": "queued",
+        }
+
+        if file_size is not None:
+            metadata["file_size"] = file_size
+
+        return await self.find_or_create_notification(
+            session=session,
+            user_id=user_id,
+            operation_id=operation_id,
+            title=title,
+            message=message,
+            search_space_id=search_space_id,
+            initial_metadata=metadata,
+        )
+
+    async def notify_processing_progress(
+        self,
+        session: AsyncSession,
+        notification: Notification,
+        stage: str,
+        stage_message: str | None = None,
+        chunks_count: int | None = None,
+    ) -> Notification:
+        """
+        Update notification with processing progress.
+
+        Args:
+            session: Database session
+            notification: Notification to update
+            stage: Current processing stage (parsing, chunking, embedding, storing)
+            stage_message: Optional custom message for the stage
+            chunks_count: Number of chunks created (optional, stored in metadata only)
+
+        Returns:
+            Updated notification
+        """
+        # User-friendly stage messages
+        stage_messages = {
+            "parsing": "Reading your file",
+            "chunking": "Preparing for search",
+            "embedding": "Preparing for search",
+            "storing": "Finalizing",
+        }
+
+        message = stage_message or stage_messages.get(stage, "Processing")
+
+        metadata_updates = {"processing_stage": stage}
+        # Store chunks_count in metadata for debugging, but don't show to user
+        if chunks_count is not None:
+            metadata_updates["chunks_count"] = chunks_count
+
+        return await self.update_notification(
+            session=session,
+            notification=notification,
+            message=message,
+            status="in_progress",
+            metadata_updates=metadata_updates,
+        )
+
+    async def notify_processing_completed(
+        self,
+        session: AsyncSession,
+        notification: Notification,
+        document_id: int | None = None,
+        chunks_count: int | None = None,
+        error_message: str | None = None,
+    ) -> Notification:
+        """
+        Update notification when document processing completes.
+
+        Args:
+            session: Database session
+            notification: Notification to update
+            document_id: ID of the created document (optional)
+            chunks_count: Total number of chunks created (optional)
+            error_message: Error message if processing failed (optional)
+
+        Returns:
+            Updated notification
+        """
+        document_name = notification.notification_metadata.get(
+            "document_name", "Document"
+        )
+
+        if error_message:
+            title = f"Failed: {document_name}"
+            message = f"Processing failed: {error_message}"
+            status = "failed"
+        else:
+            title = f"Ready: {document_name}"
+            message = "Now searchable!"
+            status = "completed"
+
+        metadata_updates = {
+            "processing_stage": "completed" if not error_message else "failed",
+            "error_message": error_message,
+        }
+
+        if document_id is not None:
+            metadata_updates["document_id"] = document_id
+        # Store chunks_count in metadata for debugging, but don't show to user
+        if chunks_count is not None:
+            metadata_updates["chunks_count"] = chunks_count
+
+        return await self.update_notification(
+            session=session,
+            notification=notification,
+            title=title,
+            message=message,
+            status=status,
+            metadata_updates=metadata_updates,
+        )
+
+
+class NotificationService:
+    """Service for creating and managing notifications that sync via Electric SQL."""
+
+    # Handler instances
+    connector_indexing = ConnectorIndexingNotificationHandler()
+    document_processing = DocumentProcessingNotificationHandler()
+
+    @staticmethod
+    async def create_notification(
+        session: AsyncSession,
+        user_id: UUID,
+        notification_type: str,
+        title: str,
+        message: str,
+        search_space_id: int | None = None,
+        notification_metadata: dict[str, Any] | None = None,
+    ) -> Notification:
+        """
+        Create a notification - Electric SQL will automatically sync it to frontend.
+
+        Args:
+            session: Database session
+            user_id: User to notify
+            notification_type: Type of notification (e.g., 'document_processing', 'connector_indexing')
+            title: Notification title
+            message: Notification message
+            search_space_id: Optional search space ID
+            notification_metadata: Optional metadata dictionary
+
+        Returns:
+            Notification: The created notification
+        """
+        notification = Notification(
+            user_id=user_id,
+            search_space_id=search_space_id,
+            type=notification_type,
+            title=title,
+            message=message,
+            notification_metadata=notification_metadata or {},
+        )
+        session.add(notification)
+        await session.commit()
+        await session.refresh(notification)
+        logger.info(f"Created notification {notification.id} for user {user_id}")
+        return notification

surfsense_backend/app/tasks/celery_tasks/connector_tasks.py

@@ -445,31 +445,13 @@ async def _index_google_gmail_messages(
     end_date: str,
 ):
     """Index Google Gmail messages with new session."""
-    from datetime import datetime
-
     from app.routes.search_source_connectors_routes import (
         run_google_gmail_indexing,
     )
 
-    # Parse dates to calculate days_back
-    max_messages = 100
-    days_back = 30  # Default
-
-    if start_date:
-        try:
-            # Parse start_date (format: YYYY-MM-DD)
-            start_dt = datetime.strptime(start_date, "%Y-%m-%d")
-            # Calculate days back from now
-            days_back = (datetime.now() - start_dt).days
-            # Ensure at least 1 day
-            days_back = max(1, days_back)
-        except ValueError:
-            # If parsing fails, use default
-            days_back = 30
-
     async with get_celery_session_maker()() as session:
         await run_google_gmail_indexing(
-            session, connector_id, search_space_id, user_id, max_messages, days_back
+            session, connector_id, search_space_id, user_id, start_date, end_date
         )
 
 
@@ -479,7 +461,7 @@ def index_google_drive_files_task(
     connector_id: int,
     search_space_id: int,
     user_id: str,
-    items_dict: dict,  # Dictionary with 'folders' and 'files' lists
+    items_dict: dict,  # Dictionary with 'folders', 'files', and 'indexing_options'
 ):
     """Celery task to index Google Drive folders and files."""
     import asyncio
@@ -504,7 +486,7 @@ async def _index_google_drive_files(
     connector_id: int,
     search_space_id: int,
     user_id: str,
-    items_dict: dict,  # Dictionary with 'folders' and 'files' lists
+    items_dict: dict,  # Dictionary with 'folders', 'files', and 'indexing_options'
 ):
     """Index Google Drive folders and files with new session."""
     from app.routes.search_source_connectors_routes import (

surfsense_backend/app/tasks/celery_tasks/document_tasks.py

@@ -1,12 +1,14 @@
 """Celery tasks for document processing."""
 
 import logging
+from uuid import UUID
 
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 from sqlalchemy.pool import NullPool
 
 from app.celery_app import celery_app
 from app.config import config
+from app.services.notification_service import NotificationService
 from app.services.task_logging_service import TaskLoggingService
 from app.tasks.document_processors import (
     add_extension_received_document,
@@ -84,6 +86,22 @@ async def _process_extension_document(
     async with get_celery_session_maker()() as session:
         task_logger = TaskLoggingService(session, search_space_id)
 
+        # Truncate title for notification display
+        page_title = individual_document.metadata.VisitedWebPageTitle[:50]
+        if len(individual_document.metadata.VisitedWebPageTitle) > 50:
+            page_title += "..."
+
+        # Create notification for document processing
+        notification = (
+            await NotificationService.document_processing.notify_processing_started(
+                session=session,
+                user_id=UUID(user_id),
+                document_type="EXTENSION",
+                document_name=page_title,
+                search_space_id=search_space_id,
+            )
+        )
+
         log_entry = await task_logger.log_task_start(
             task_name="process_extension_document",
             source="document_processor",
@@ -97,6 +115,14 @@ async def _process_extension_document(
         )
 
         try:
+            # Update notification: parsing stage
+            await NotificationService.document_processing.notify_processing_progress(
+                session,
+                notification,
+                stage="parsing",
+                stage_message="Reading page content",
+            )
+
             result = await add_extension_received_document(
                 session, individual_document, search_space_id, user_id
             )
@@ -107,12 +133,31 @@ async def _process_extension_document(
                     f"Successfully processed extension document: {individual_document.metadata.VisitedWebPageTitle}",
                     {"document_id": result.id, "content_hash": result.content_hash},
                 )
+
+                # Update notification on success
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        document_id=result.id,
+                        chunks_count=None,
+                    )
+                )
             else:
                 await task_logger.log_task_success(
                     log_entry,
                     f"Extension document already exists (duplicate): {individual_document.metadata.VisitedWebPageTitle}",
                     {"duplicate_detected": True},
                 )
+
+                # Update notification for duplicate
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message="Page already saved (duplicate)",
+                    )
+                )
         except Exception as e:
             await task_logger.log_task_failure(
                 log_entry,
@@ -120,6 +165,23 @@ async def _process_extension_document(
                 str(e),
                 {"error_type": type(e).__name__},
             )
+
+            # Update notification on failure - wrapped in try-except to ensure it doesn't fail silently
+            try:
+                # Refresh notification to ensure it's not stale after any rollback
+                await session.refresh(notification)
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message=str(e)[:100],
+                    )
+                )
+            except Exception as notif_error:
+                logger.error(
+                    f"Failed to update notification on failure: {notif_error!s}"
+                )
+
             logger.error(f"Error processing extension document: {e!s}")
             raise
 
@@ -150,6 +212,20 @@ async def _process_youtube_video(url: str, search_space_id: int, user_id: str):
     async with get_celery_session_maker()() as session:
         task_logger = TaskLoggingService(session, search_space_id)
 
+        # Extract video title from URL for notification (will be updated later)
+        video_name = url.split("v=")[-1][:11] if "v=" in url else url
+
+        # Create notification for document processing
+        notification = (
+            await NotificationService.document_processing.notify_processing_started(
+                session=session,
+                user_id=UUID(user_id),
+                document_type="YOUTUBE_VIDEO",
+                document_name=f"YouTube: {video_name}",
+                search_space_id=search_space_id,
+            )
+        )
+
         log_entry = await task_logger.log_task_start(
             task_name="process_youtube_video",
             source="document_processor",
@@ -158,6 +234,14 @@ async def _process_youtube_video(url: str, search_space_id: int, user_id: str):
         )
 
         try:
+            # Update notification: parsing (fetching transcript)
+            await NotificationService.document_processing.notify_processing_progress(
+                session,
+                notification,
+                stage="parsing",
+                stage_message="Fetching video transcript",
+            )
+
             result = await add_youtube_video_document(
                 session, url, search_space_id, user_id
             )
@@ -172,12 +256,31 @@ async def _process_youtube_video(url: str, search_space_id: int, user_id: str):
                         "content_hash": result.content_hash,
                     },
                 )
+
+                # Update notification on success
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        document_id=result.id,
+                        chunks_count=None,
+                    )
+                )
             else:
                 await task_logger.log_task_success(
                     log_entry,
                     f"YouTube video document already exists (duplicate): {url}",
                     {"duplicate_detected": True},
                 )
+
+                # Update notification for duplicate
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message="Video already exists (duplicate)",
+                    )
+                )
         except Exception as e:
             await task_logger.log_task_failure(
                 log_entry,
@@ -185,6 +288,23 @@ async def _process_youtube_video(url: str, search_space_id: int, user_id: str):
                 str(e),
                 {"error_type": type(e).__name__},
             )
+
+            # Update notification on failure - wrapped in try-except to ensure it doesn't fail silently
+            try:
+                # Refresh notification to ensure it's not stale after any rollback
+                await session.refresh(notification)
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message=str(e)[:100],
+                    )
+                )
+            except Exception as notif_error:
+                logger.error(
+                    f"Failed to update notification on failure: {notif_error!s}"
+                )
+
             logger.error(f"Error processing YouTube video: {e!s}")
             raise
 
@@ -219,11 +339,31 @@ async def _process_file_upload(
     file_path: str, filename: str, search_space_id: int, user_id: str
 ):
     """Process file upload with new session."""
+    import os
+
     from app.tasks.document_processors.file_processors import process_file_in_background
 
     async with get_celery_session_maker()() as session:
         task_logger = TaskLoggingService(session, search_space_id)
 
+        # Get file size for notification metadata
+        try:
+            file_size = os.path.getsize(file_path)
+        except Exception:
+            file_size = None
+
+        # Create notification for document processing
+        notification = (
+            await NotificationService.document_processing.notify_processing_started(
+                session=session,
+                user_id=UUID(user_id),
+                document_type="FILE",
+                document_name=filename,
+                search_space_id=search_space_id,
+                file_size=file_size,
+            )
+        )
+
         log_entry = await task_logger.log_task_start(
             task_name="process_file_upload",
             source="document_processor",
@@ -237,7 +377,7 @@ async def _process_file_upload(
         )
 
         try:
-            await process_file_in_background(
+            result = await process_file_in_background(
                 file_path,
                 filename,
                 search_space_id,
@@ -245,7 +385,29 @@ async def _process_file_upload(
                 session,
                 task_logger,
                 log_entry,
+                notification=notification,
             )
+
+            # Update notification on success
+            if result:
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        document_id=result.id,
+                        chunks_count=None,
+                    )
+                )
+            else:
+                # Duplicate detected
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message="Document already exists (duplicate)",
+                    )
+                )
+
         except Exception as e:
             # Import here to avoid circular dependencies
             from fastapi import HTTPException
@@ -258,7 +420,23 @@ async def _process_file_upload(
             elif isinstance(e, HTTPException) and "page limit" in str(e.detail).lower():
                 error_message = str(e.detail)
             else:
-                error_message = f"Failed to process file: {filename}"
+                error_message = str(e)[:100]
+
+            # Update notification on failure - wrapped in try-except to ensure it doesn't fail silently
+            try:
+                # Refresh notification to ensure it's not stale after any rollback
+                await session.refresh(notification)
+                await (
+                    NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message=error_message,
+                    )
+                )
+            except Exception as notif_error:
+                logger.error(
+                    f"Failed to update notification on failure: {notif_error!s}"
+                )
 
             await task_logger.log_task_failure(
                 log_entry,
@@ -323,6 +501,22 @@ async def _process_circleback_meeting(
     async with get_celery_session_maker()() as session:
         task_logger = TaskLoggingService(session, search_space_id)
 
+        # Get user_id from metadata if available
+        user_id = metadata.get("user_id")
+
+        # Create notification if user_id is available
+        notification = None
+        if user_id:
+            notification = (
+                await NotificationService.document_processing.notify_processing_started(
+                    session=session,
+                    user_id=UUID(user_id),
+                    document_type="CIRCLEBACK",
+                    document_name=f"Meeting: {meeting_name[:40]}",
+                    search_space_id=search_space_id,
+                )
+            )
+
         log_entry = await task_logger.log_task_start(
             task_name="process_circleback_meeting",
             source="circleback_webhook",
@@ -336,6 +530,17 @@ async def _process_circleback_meeting(
         )
 
         try:
+            # Update notification: parsing stage
+            if notification:
+                await (
+                    NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="parsing",
+                        stage_message="Reading meeting notes",
+                    )
+                )
+
             result = await add_circleback_meeting_document(
                 session=session,
                 meeting_id=meeting_id,
@@ -355,12 +560,29 @@ async def _process_circleback_meeting(
                         "content_hash": result.content_hash,
                     },
                 )
+
+                # Update notification on success
+                if notification:
+                    await NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        document_id=result.id,
+                        chunks_count=None,
+                    )
             else:
                 await task_logger.log_task_success(
                     log_entry,
                     f"Circleback meeting document already exists (duplicate): {meeting_name}",
                     {"duplicate_detected": True, "meeting_id": meeting_id},
                 )
+
+                # Update notification for duplicate
+                if notification:
+                    await NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message="Meeting already saved (duplicate)",
+                    )
         except Exception as e:
             await task_logger.log_task_failure(
                 log_entry,
@@ -368,5 +590,21 @@ async def _process_circleback_meeting(
                 str(e),
                 {"error_type": type(e).__name__, "meeting_id": meeting_id},
             )
+
+            # Update notification on failure - wrapped in try-except to ensure it doesn't fail silently
+            if notification:
+                try:
+                    # Refresh notification to ensure it's not stale after any rollback
+                    await session.refresh(notification)
+                    await NotificationService.document_processing.notify_processing_completed(
+                        session=session,
+                        notification=notification,
+                        error_message=str(e)[:100],
+                    )
+                except Exception as notif_error:
+                    logger.error(
+                        f"Failed to update notification on failure: {notif_error!s}"
+                    )
+
             logger.error(f"Error processing Circleback meeting: {e!s}")
             raise

surfsense_backend/app/tasks/celery_tasks/schedule_checker_task.py

@@ -72,6 +72,7 @@ async def _check_and_trigger_schedules():
                 index_elasticsearch_documents_task,
                 index_github_repos_task,
                 index_google_calendar_events_task,
+                index_google_drive_files_task,
                 index_google_gmail_messages_task,
                 index_jira_issues_task,
                 index_linear_issues_task,
@@ -96,6 +97,7 @@ async def _check_and_trigger_schedules():
                 SearchSourceConnectorType.LUMA_CONNECTOR: index_luma_events_task,
                 SearchSourceConnectorType.ELASTICSEARCH_CONNECTOR: index_elasticsearch_documents_task,
                 SearchSourceConnectorType.WEBCRAWLER_CONNECTOR: index_crawled_urls_task,
+                SearchSourceConnectorType.GOOGLE_DRIVE_CONNECTOR: index_google_drive_files_task,
             }
 
             # Trigger indexing for each due connector
@@ -106,13 +108,57 @@ async def _check_and_trigger_schedules():
                         f"Triggering periodic indexing for connector {connector.id} "
                         f"({connector.connector_type.value})"
                     )
-                    task.delay(
-                        connector.id,
-                        connector.search_space_id,
-                        str(connector.user_id),
-                        None,  # start_date - uses last_indexed_at
-                        None,  # end_date - uses now
-                    )
+
+                    # Special handling for Google Drive - uses config for folder/file selection
+                    if (
+                        connector.connector_type
+                        == SearchSourceConnectorType.GOOGLE_DRIVE_CONNECTOR
+                    ):
+                        connector_config = connector.config or {}
+                        selected_folders = connector_config.get("selected_folders", [])
+                        selected_files = connector_config.get("selected_files", [])
+                        indexing_options = connector_config.get(
+                            "indexing_options",
+                            {
+                                "max_files_per_folder": 100,
+                                "incremental_sync": True,
+                                "include_subfolders": True,
+                            },
+                        )
+
+                        if selected_folders or selected_files:
+                            task.delay(
+                                connector.id,
+                                connector.search_space_id,
+                                str(connector.user_id),
+                                {
+                                    "folders": selected_folders,
+                                    "files": selected_files,
+                                    "indexing_options": indexing_options,
+                                },
+                            )
+                        else:
+                            # No folders/files selected - skip indexing but still update next_scheduled_at
+                            # to prevent checking every minute
+                            logger.info(
+                                f"Google Drive connector {connector.id} has no folders or files selected, "
+                                "skipping periodic indexing (will check again at next scheduled time)"
+                            )
+                            from datetime import timedelta
+
+                            connector.next_scheduled_at = now + timedelta(
+                                minutes=connector.indexing_frequency_minutes
+                            )
+                            await session.commit()
+                            continue
+                    else:
+                        task.delay(
+                            connector.id,
+                            connector.search_space_id,
+                            str(connector.user_id),
+                            None,  # start_date - uses last_indexed_at
+                            None,  # end_date - uses now
+                        )
 
                     # Update next_scheduled_at for next run
                     from datetime import timedelta

surfsense_backend/app/tasks/chat/stream_new_chat.py

@@ -423,9 +423,9 @@ async def stream_new_chat(
                     title = title[:27] + "..."
                 doc_names.append(title)
             if len(doc_names) == 1:
-                processing_parts.append(f"[📖 {doc_names[0]}]")
+                processing_parts.append(f"[{doc_names[0]}]")
             else:
-                processing_parts.append(f"[📖 {len(doc_names)} docs]")
+                processing_parts.append(f"[{len(doc_names)} docs]")
 
         last_active_step_items = [f"{action_verb}: {' '.join(processing_parts)}"]
 

surfsense_backend/app/tasks/connector_indexers/discord_indexer.py

@@ -549,7 +549,10 @@ async def index_discord_messages(
         logger.info(
             f"Discord indexing completed: {documents_indexed} new messages, {documents_skipped} skipped"
         )
-        return documents_indexed, result_message
+        return (
+            documents_indexed,
+            None,
+        )  # Return None on success (result_message is for logging only)
 
     except SQLAlchemyError as db_error:
         await session.rollback()

surfsense_backend/app/tasks/connector_indexers/google_drive_indexer.py

@@ -37,6 +37,7 @@ async def index_google_drive_files(
     use_delta_sync: bool = True,
     update_last_indexed: bool = True,
     max_files: int = 500,
+    include_subfolders: bool = False,
 ) -> tuple[int, str | None]:
     """
     Index Google Drive files for a specific connector.
@@ -51,6 +52,7 @@ async def index_google_drive_files(
         use_delta_sync: Whether to use change tracking for incremental sync
         update_last_indexed: Whether to update last_indexed_at timestamp
         max_files: Maximum number of files to index
+        include_subfolders: Whether to recursively index files in subfolders
 
     Returns:
         Tuple of (number_of_indexed_files, error_message)
@@ -144,6 +146,7 @@ async def index_google_drive_files(
                 task_logger=task_logger,
                 log_entry=log_entry,
                 max_files=max_files,
+                include_subfolders=include_subfolders,
             )
         else:
             logger.info(f"Using full scan for connector {connector_id}")
@@ -159,6 +162,7 @@ async def index_google_drive_files(
                 task_logger=task_logger,
                 log_entry=log_entry,
                 max_files=max_files,
+                include_subfolders=include_subfolders,
             )
 
         documents_indexed, documents_skipped = result
@@ -168,6 +172,9 @@ async def index_google_drive_files(
             if new_token and not token_error:
                 from sqlalchemy.orm.attributes import flag_modified
 
+                # Refresh connector to reload attributes that may have been expired by earlier commits
+                await session.refresh(connector)
+
                 if "folder_tokens" not in connector.config:
                     connector.config["folder_tokens"] = {}
                 connector.config["folder_tokens"][target_folder_id] = new_token
@@ -375,60 +382,89 @@ async def _index_full_scan(
     task_logger: TaskLoggingService,
     log_entry: any,
     max_files: int,
+    include_subfolders: bool = False,
 ) -> tuple[int, int]:
     """Perform full scan indexing of a folder."""
     await task_logger.log_task_progress(
         log_entry,
-        f"Starting full scan of folder: {folder_name}",
-        {"stage": "full_scan", "folder_id": folder_id},
+        f"Starting full scan of folder: {folder_name} (include_subfolders={include_subfolders})",
+        {
+            "stage": "full_scan",
+            "folder_id": folder_id,
+            "include_subfolders": include_subfolders,
+        },
     )
 
     documents_indexed = 0
     documents_skipped = 0
-    page_token = None
     files_processed = 0
 
-    while files_processed < max_files:
-        files, next_token, error = await get_files_in_folder(
-            drive_client, folder_id, include_subfolders=False, page_token=page_token
-        )
+    # Queue of folders to process: (folder_id, folder_name)
+    folders_to_process = [(folder_id, folder_name)]
 
-        if error:
-            logger.error(f"Error listing files: {error}")
-            break
+    while folders_to_process and files_processed < max_files:
+        current_folder_id, current_folder_name = folders_to_process.pop(0)
+        logger.info(f"Processing folder: {current_folder_name} ({current_folder_id})")
+        page_token = None
 
-        if not files:
-            break
-
-        for file in files:
-            if files_processed >= max_files:
-                break
-
-            files_processed += 1
-
-            indexed, skipped = await _process_single_file(
-                drive_client=drive_client,
-                session=session,
-                file=file,
-                connector_id=connector_id,
-                search_space_id=search_space_id,
-                user_id=user_id,
-                task_logger=task_logger,
-                log_entry=log_entry,
+        while files_processed < max_files:
+            # Get files and folders in current folder
+            # include_subfolders=True here so we get folder items to queue them
+            files, next_token, error = await get_files_in_folder(
+                drive_client,
+                current_folder_id,
+                include_subfolders=True,
+                page_token=page_token,
             )
 
-            documents_indexed += indexed
-            documents_skipped += skipped
+            if error:
+                logger.error(f"Error listing files in {current_folder_name}: {error}")
+                break
 
-            if documents_indexed % 10 == 0 and documents_indexed > 0:
-                await session.commit()
-                logger.info(
-                    f"Committed batch: {documents_indexed} files indexed so far"
+            if not files:
+                break
+
+            for file in files:
+                if files_processed >= max_files:
+                    break
+
+                mime_type = file.get("mimeType", "")
+
+                # If this is a folder and include_subfolders is enabled, queue it for processing
+                if mime_type == "application/vnd.google-apps.folder":
+                    if include_subfolders:
+                        folders_to_process.append(
+                            (file["id"], file.get("name", "Unknown"))
+                        )
+                        logger.debug(f"Queued subfolder: {file.get('name', 'Unknown')}")
+                    continue
+
+                # Process the file
+                files_processed += 1
+
+                indexed, skipped = await _process_single_file(
+                    drive_client=drive_client,
+                    session=session,
+                    file=file,
+                    connector_id=connector_id,
+                    search_space_id=search_space_id,
+                    user_id=user_id,
+                    task_logger=task_logger,
+                    log_entry=log_entry,
                 )
 
-        page_token = next_token
-        if not page_token:
-            break
+                documents_indexed += indexed
+                documents_skipped += skipped
+
+                if documents_indexed % 10 == 0 and documents_indexed > 0:
+                    await session.commit()
+                    logger.info(
+                        f"Committed batch: {documents_indexed} files indexed so far"
+                    )
+
+            page_token = next_token
+            if not page_token:
+                break
 
     logger.info(
         f"Full scan complete: {documents_indexed} indexed, {documents_skipped} skipped"
@@ -448,8 +484,13 @@ async def _index_with_delta_sync(
     task_logger: TaskLoggingService,
     log_entry: any,
     max_files: int,
+    include_subfolders: bool = False,
 ) -> tuple[int, int]:
-    """Perform delta sync indexing using change tracking."""
+    """Perform delta sync indexing using change tracking.
+
+    Note: include_subfolders is accepted for API consistency but delta sync
+    automatically tracks changes across all folders including subfolders.
+    """
     await task_logger.log_task_progress(
         log_entry,
         f"Starting delta sync from token: {start_page_token[:20]}...",
@@ -515,6 +556,131 @@ async def _index_with_delta_sync(
     return documents_indexed, documents_skipped
 
 
+async def _check_rename_only_update(
+    session: AsyncSession,
+    file: dict,
+    search_space_id: int,
+) -> tuple[bool, str | None]:
+    """
+    Check if a file only needs a rename update (no content change).
+
+    Uses md5Checksum comparison (preferred) or modifiedTime (fallback for Google Workspace files)
+    to detect if content has changed. This optimization prevents unnecessary ETL API calls
+    (Docling/LlamaCloud) for rename-only operations.
+
+    Args:
+        session: Database session
+        file: File metadata from Google Drive API
+        search_space_id: ID of the search space
+
+    Returns:
+        Tuple of (is_rename_only, message)
+        - (True, message): Only filename changed, document was updated
+        - (False, None): Content changed or new file, needs full processing
+    """
+    from sqlalchemy import select
+    from sqlalchemy.orm.attributes import flag_modified
+
+    from app.db import Document
+
+    file_id = file.get("id")
+    file_name = file.get("name", "Unknown")
+    incoming_md5 = file.get("md5Checksum")  # None for Google Workspace files
+    incoming_modified_time = file.get("modifiedTime")
+
+    if not file_id:
+        return False, None
+
+    # Try to find existing document by file_id-based hash (primary method)
+    primary_hash = generate_unique_identifier_hash(
+        DocumentType.GOOGLE_DRIVE_FILE, file_id, search_space_id
+    )
+    existing_document = await check_document_by_unique_identifier(session, primary_hash)
+
+    # If not found by primary hash, try searching by metadata (for legacy documents)
+    if not existing_document:
+        result = await session.execute(
+            select(Document).where(
+                Document.search_space_id == search_space_id,
+                Document.document_type == DocumentType.GOOGLE_DRIVE_FILE,
+                Document.document_metadata["google_drive_file_id"].astext == file_id,
+            )
+        )
+        existing_document = result.scalar_one_or_none()
+        if existing_document:
+            logger.debug(f"Found legacy document by metadata for file_id: {file_id}")
+
+    if not existing_document:
+        # New file, needs full processing
+        return False, None
+
+    # Get stored checksums/timestamps from document metadata
+    doc_metadata = existing_document.document_metadata or {}
+    stored_md5 = doc_metadata.get("md5_checksum")
+    stored_modified_time = doc_metadata.get("modified_time")
+
+    # Determine if content changed using md5Checksum (preferred) or modifiedTime (fallback)
+    content_unchanged = False
+
+    if incoming_md5 and stored_md5:
+        # Best case: Compare md5 checksums (only changes when content changes, not on rename)
+        content_unchanged = incoming_md5 == stored_md5
+        logger.debug(f"MD5 comparison for {file_name}: unchanged={content_unchanged}")
+    elif incoming_md5 and not stored_md5:
+        # Have incoming md5 but no stored md5 (legacy doc) - need to reprocess to store it
+        logger.debug(
+            f"No stored md5 for {file_name}, will reprocess to store md5_checksum"
+        )
+        return False, None
+    elif not incoming_md5:
+        # Google Workspace file (no md5Checksum available) - fall back to modifiedTime
+        # Note: modifiedTime is less reliable as it changes on rename too, but it's the best we have
+        if incoming_modified_time and stored_modified_time:
+            content_unchanged = incoming_modified_time == stored_modified_time
+            logger.debug(
+                f"ModifiedTime fallback for Google Workspace file {file_name}: unchanged={content_unchanged}"
+            )
+        else:
+            # No stored modifiedTime (legacy) - reprocess to store it
+            return False, None
+
+    if content_unchanged:
+        # Content hasn't changed - check if filename changed
+        old_name = doc_metadata.get("FILE_NAME") or doc_metadata.get(
+            "google_drive_file_name"
+        )
+
+        if old_name and old_name != file_name:
+            # Rename-only update - update the document without re-processing
+            existing_document.title = file_name
+            if not existing_document.document_metadata:
+                existing_document.document_metadata = {}
+            existing_document.document_metadata["FILE_NAME"] = file_name
+            existing_document.document_metadata["google_drive_file_name"] = file_name
+            # Also update modified_time for Google Workspace files (since it changed on rename)
+            if incoming_modified_time:
+                existing_document.document_metadata["modified_time"] = (
+                    incoming_modified_time
+                )
+            flag_modified(existing_document, "document_metadata")
+            await session.commit()
+
+            logger.info(
+                f"Rename-only update: '{old_name}' → '{file_name}' (skipped ETL)"
+            )
+            return (
+                True,
+                f"File renamed: '{old_name}' → '{file_name}' (no content change)",
+            )
+        else:
+            # Neither content nor name changed
+            logger.debug(f"File unchanged: {file_name}")
+            return True, "File unchanged (same content and name)"
+
+    # Content changed - needs full processing
+    return False, None
+
+
 async def _process_single_file(
     drive_client: GoogleDriveClient,
     session: AsyncSession,
@@ -537,6 +703,27 @@ async def _process_single_file(
     try:
         logger.info(f"Processing file: {file_name} ({mime_type})")
 
+        # Early check: Is this a rename-only update?
+        # This optimization prevents downloading and ETL processing for files
+        # where only the name changed but content is the same.
+        is_rename_only, rename_message = await _check_rename_only_update(
+            session=session,
+            file=file,
+            search_space_id=search_space_id,
+        )
+
+        if is_rename_only:
+            await task_logger.log_task_progress(
+                log_entry,
+                f"Skipped ETL for {file_name}: {rename_message}",
+                {"status": "rename_only", "reason": rename_message},
+            )
+            # Return 1 for renamed files (they are "indexed" in the sense that they're updated)
+            # Return 0 for unchanged files
+            if "renamed" in (rename_message or "").lower():
+                return 1, 0
+            return 0, 1
+
         _, error, _ = await download_and_process_file(
             client=drive_client,
             file=file,
@@ -564,7 +751,15 @@ async def _process_single_file(
 
 
 async def _remove_document(session: AsyncSession, file_id: str, search_space_id: int):
-    """Remove a document that was deleted in Drive."""
+    """Remove a document that was deleted in Drive.
+
+    Handles both new (file_id-based) and legacy (filename-based) hash schemes.
+    """
+    from sqlalchemy import select
+
+    from app.db import Document
+
+    # First try with file_id-based hash (new method)
     unique_identifier_hash = generate_unique_identifier_hash(
         DocumentType.GOOGLE_DRIVE_FILE, file_id, search_space_id
     )
@@ -573,6 +768,19 @@ async def _remove_document(session: AsyncSession, file_id: str, search_space_id:
         session, unique_identifier_hash
     )
 
+    # If not found, search by metadata (for legacy documents with filename-based hash)
+    if not existing_document:
+        result = await session.execute(
+            select(Document).where(
+                Document.search_space_id == search_space_id,
+                Document.document_type == DocumentType.GOOGLE_DRIVE_FILE,
+                Document.document_metadata["google_drive_file_id"].astext == file_id,
+            )
+        )
+        existing_document = result.scalar_one_or_none()
+        if existing_document:
+            logger.info(f"Found legacy document by metadata for file_id: {file_id}")
+
     if existing_document:
         await session.delete(existing_document)
         logger.info(f"Removed deleted file document: {file_id}")

surfsense_backend/app/tasks/connector_indexers/notion_indexer.py

@@ -464,7 +464,10 @@ async def index_notion_pages(
         # Clean up the async client
         await notion_client.close()
 
-        return total_processed, result_message
+        return (
+            total_processed,
+            None,
+        )  # Return None on success (result_message is for logging only)
 
     except SQLAlchemyError as db_error:
         await session.rollback()

surfsense_backend/app/tasks/connector_indexers/slack_indexer.py

@@ -413,7 +413,10 @@ async def index_slack_messages(
         logger.info(
             f"Slack indexing completed: {documents_indexed} new channels, {documents_skipped} skipped"
         )
-        return total_processed, result_message
+        return (
+            total_processed,
+            None,
+        )  # Return None on success (result_message is for logging only)
 
     except SQLAlchemyError as db_error:
         await session.rollback()

surfsense_backend/app/tasks/connector_indexers/teams_indexer.py

@@ -460,7 +460,10 @@ async def index_teams_messages(
             documents_indexed,
             documents_skipped,
         )
-        return total_processed, result_message
+        return (
+            total_processed,
+            None,
+        )  # Return None on success (result_message is for logging only)
 
     except SQLAlchemyError as db_error:
         await session.rollback()

surfsense_backend/app/tasks/connector_indexers/webcrawler_indexer.py

@@ -371,17 +371,14 @@ async def index_crawled_urls(
         )
         await session.commit()
 
-        # Build result message
-        result_message = None
+        # Log failed URLs if any (for debugging purposes)
         if failed_urls:
             failed_summary = "; ".join(
                 [f"{url}: {error}" for url, error in failed_urls[:5]]
             )
             if len(failed_urls) > 5:
                 failed_summary += f" (and {len(failed_urls) - 5} more)"
-            result_message = (
-                f"Completed with {len(failed_urls)} failures: {failed_summary}"
-            )
+            logger.warning(f"Some URLs failed to index: {failed_summary}")
 
         await task_logger.log_task_success(
             log_entry,
@@ -400,7 +397,10 @@ async def index_crawled_urls(
             f"{documents_updated} updated, {documents_skipped} skipped, "
             f"{len(failed_urls)} failed"
         )
-        return total_processed, result_message
+        return (
+            total_processed,
+            None,
+        )  # Return None on success (result_message is for logging only)
 
     except SQLAlchemyError as db_error:
         await session.rollback()

surfsense_backend/app/tasks/document_processors/file_processors.py

@@ -17,8 +17,9 @@ from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import config as app_config
-from app.db import Document, DocumentType, Log
+from app.db import Document, DocumentType, Log, Notification
 from app.services.llm_service import get_user_long_context_llm
+from app.services.notification_service import NotificationService
 from app.services.task_logging_service import TaskLoggingService
 from app.utils.document_converters import (
     convert_document_to_markdown,
@@ -30,6 +31,7 @@ from app.utils.document_converters import (
 
 from .base import (
     check_document_by_unique_identifier,
+    check_duplicate_document,
     get_current_timestamp,
 )
 from .markdown_processor import add_received_markdown_file_document
@@ -48,6 +50,160 @@ LLAMACLOUD_RETRYABLE_EXCEPTIONS = (
 )
 
 
+def get_google_drive_unique_identifier(
+    connector: dict | None,
+    filename: str,
+    search_space_id: int,
+) -> tuple[str, str | None]:
+    """
+    Get unique identifier hash for a file, with special handling for Google Drive.
+
+    For Google Drive files, uses file_id as the unique identifier (doesn't change on rename).
+    For other files, uses filename.
+
+    Args:
+        connector: Optional connector info dict with type and metadata
+        filename: The filename (used for non-Google Drive files or as fallback)
+        search_space_id: The search space ID
+
+    Returns:
+        Tuple of (primary_hash, legacy_hash or None)
+        - For Google Drive: (file_id_based_hash, filename_based_hash for migration)
+        - For other sources: (filename_based_hash, None)
+    """
+    if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+        metadata = connector.get("metadata", {})
+        file_id = metadata.get("google_drive_file_id")
+
+        if file_id:
+            # New method: use file_id as unique identifier (doesn't change on rename)
+            primary_hash = generate_unique_identifier_hash(
+                DocumentType.GOOGLE_DRIVE_FILE, file_id, search_space_id
+            )
+            # Legacy method: for backward compatibility with existing documents
+            # that were indexed with filename-based hash
+            legacy_hash = generate_unique_identifier_hash(
+                DocumentType.GOOGLE_DRIVE_FILE, filename, search_space_id
+            )
+            return primary_hash, legacy_hash
+
+    # For non-Google Drive files, use filename as before
+    primary_hash = generate_unique_identifier_hash(
+        DocumentType.FILE, filename, search_space_id
+    )
+    return primary_hash, None
+
+
+async def handle_existing_document_update(
+    session: AsyncSession,
+    existing_document: Document,
+    content_hash: str,
+    connector: dict | None,
+    filename: str,
+    primary_hash: str,
+) -> tuple[bool, Document | None]:
+    """
+    Handle update logic for an existing document.
+
+    Args:
+        session: Database session
+        existing_document: The existing document found in database
+        content_hash: Hash of the new content
+        connector: Optional connector info
+        filename: Current filename
+        primary_hash: The primary hash (file_id based for Google Drive)
+
+    Returns:
+        Tuple of (should_skip_processing, document_to_return)
+        - (True, document): Content unchanged, just return existing document
+        - (False, None): Content changed, need to re-process
+    """
+    # Check if this document needs hash migration (found via legacy hash)
+    if existing_document.unique_identifier_hash != primary_hash:
+        existing_document.unique_identifier_hash = primary_hash
+        logging.info(f"Migrated document to file_id-based identifier: {filename}")
+
+    # Check if content has changed
+    if existing_document.content_hash == content_hash:
+        # Content unchanged - check if we need to update metadata (e.g., filename changed)
+        if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+            connector_metadata = connector.get("metadata", {})
+            new_name = connector_metadata.get("google_drive_file_name")
+            # Check both possible keys for old name (FILE_NAME is used in stored documents)
+            doc_metadata = existing_document.document_metadata or {}
+            old_name = doc_metadata.get("FILE_NAME") or doc_metadata.get(
+                "google_drive_file_name"
+            )
+
+            if new_name and old_name and old_name != new_name:
+                # File was renamed - update title and metadata, skip expensive processing
+                from sqlalchemy.orm.attributes import flag_modified
+
+                existing_document.title = new_name
+                if not existing_document.document_metadata:
+                    existing_document.document_metadata = {}
+                existing_document.document_metadata["FILE_NAME"] = new_name
+                existing_document.document_metadata["google_drive_file_name"] = new_name
+                flag_modified(existing_document, "document_metadata")
+                await session.commit()
+                logging.info(
+                    f"File renamed in Google Drive: '{old_name}' → '{new_name}' (no re-processing needed)"
+                )
+
+        logging.info(f"Document for file {filename} unchanged. Skipping.")
+        return True, existing_document
+    else:
+        # Content has changed - need to re-process
+        logging.info(f"Content changed for file {filename}. Updating document.")
+        return False, None
+
+
+async def find_existing_document_with_migration(
+    session: AsyncSession,
+    primary_hash: str,
+    legacy_hash: str | None,
+    content_hash: str | None = None,
+) -> Document | None:
+    """
+    Find existing document, checking both new hash and legacy hash for migration,
+    with fallback to content_hash for cross-source deduplication.
+
+    Args:
+        session: Database session
+        primary_hash: The primary hash (file_id based for Google Drive)
+        legacy_hash: The legacy hash (filename based) for migration, or None
+        content_hash: The content hash for fallback deduplication, or None
+
+    Returns:
+        Existing document if found, None otherwise
+    """
+    # First check with primary hash (new method)
+    existing_document = await check_document_by_unique_identifier(session, primary_hash)
+
+    # If not found and we have a legacy hash, check with that (migration path)
+    if not existing_document and legacy_hash:
+        existing_document = await check_document_by_unique_identifier(
+            session, legacy_hash
+        )
+        if existing_document:
+            logging.info(
+                "Found legacy document (filename-based hash), will migrate to file_id-based hash"
+            )
+
+    # Fallback: check by content_hash to catch duplicates from different sources
+    # This prevents unique constraint violations when the same content exists
+    # under a different unique_identifier (e.g., manual upload vs Google Drive)
+    if not existing_document and content_hash:
+        existing_document = await check_duplicate_document(session, content_hash)
+        if existing_document:
+            logging.info(
+                f"Found duplicate content from different source (content_hash match). "
+                f"Original document ID: {existing_document.id}, type: {existing_document.document_type}"
+            )
+
+    return existing_document
+
+
 async def parse_with_llamacloud_retry(
     file_path: str,
     estimated_pages: int,
@@ -157,6 +313,7 @@ async def add_received_file_document_using_unstructured(
     unstructured_processed_elements: list[LangChainDocument],
     search_space_id: int,
     user_id: str,
+    connector: dict | None = None,
 ) -> Document | None:
     """
     Process and store a file document using Unstructured service.
@@ -167,6 +324,7 @@ async def add_received_file_document_using_unstructured(
         unstructured_processed_elements: Processed elements from Unstructured
         search_space_id: ID of the search space
         user_id: ID of the user
+        connector: Optional connector info for Google Drive files
 
     Returns:
         Document object if successful, None if failed
@@ -176,29 +334,32 @@ async def add_received_file_document_using_unstructured(
             unstructured_processed_elements
         )
 
-        # Generate unique identifier hash for this file
-        unique_identifier_hash = generate_unique_identifier_hash(
-            DocumentType.FILE, file_name, search_space_id
+        # Generate unique identifier hash (uses file_id for Google Drive, filename for others)
+        primary_hash, legacy_hash = get_google_drive_unique_identifier(
+            connector, file_name, search_space_id
         )
 
         # Generate content hash
         content_hash = generate_content_hash(file_in_markdown, search_space_id)
 
-        # Check if document with this unique identifier already exists
-        existing_document = await check_document_by_unique_identifier(
-            session, unique_identifier_hash
+        # Check if document exists (with migration support for Google Drive and content_hash fallback)
+        existing_document = await find_existing_document_with_migration(
+            session, primary_hash, legacy_hash, content_hash
         )
 
         if existing_document:
-            # Document exists - check if content has changed
-            if existing_document.content_hash == content_hash:
-                logging.info(f"Document for file {file_name} unchanged. Skipping.")
-                return existing_document
-            else:
-                # Content has changed - update the existing document
-                logging.info(
-                    f"Content changed for file {file_name}. Updating document."
-                )
+            # Handle existing document (rename detection, content change check)
+            should_skip, doc = await handle_existing_document_update(
+                session,
+                existing_document,
+                content_hash,
+                connector,
+                file_name,
+                primary_hash,
+            )
+            if should_skip:
+                return doc
+            # Content changed - continue to update
 
         # Get user's long context LLM (needed for both create and update)
         user_llm = await get_user_long_context_llm(session, user_id, search_space_id)
@@ -250,10 +411,15 @@ async def add_received_file_document_using_unstructured(
             document = existing_document
         else:
             # Create new document
+            # Determine document type based on connector
+            doc_type = DocumentType.FILE
+            if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+                doc_type = DocumentType.GOOGLE_DRIVE_FILE
+
             document = Document(
                 search_space_id=search_space_id,
                 title=file_name,
-                document_type=DocumentType.FILE,
+                document_type=doc_type,
                 document_metadata={
                     "FILE_NAME": file_name,
                     "ETL_SERVICE": "UNSTRUCTURED",
@@ -262,7 +428,7 @@ async def add_received_file_document_using_unstructured(
                 embedding=summary_embedding,
                 chunks=chunks,
                 content_hash=content_hash,
-                unique_identifier_hash=unique_identifier_hash,
+                unique_identifier_hash=primary_hash,
                 blocknote_document=blocknote_json,
                 content_needs_reindexing=False,
                 updated_at=get_current_timestamp(),
@@ -287,6 +453,7 @@ async def add_received_file_document_using_llamacloud(
     llamacloud_markdown_document: str,
     search_space_id: int,
     user_id: str,
+    connector: dict | None = None,
 ) -> Document | None:
     """
     Process and store document content parsed by LlamaCloud.
@@ -297,6 +464,7 @@ async def add_received_file_document_using_llamacloud(
         llamacloud_markdown_document: Markdown content from LlamaCloud parsing
         search_space_id: ID of the search space
         user_id: ID of the user
+        connector: Optional connector info for Google Drive files
 
     Returns:
         Document object if successful, None if failed
@@ -305,29 +473,32 @@ async def add_received_file_document_using_llamacloud(
         # Combine all markdown documents into one
         file_in_markdown = llamacloud_markdown_document
 
-        # Generate unique identifier hash for this file
-        unique_identifier_hash = generate_unique_identifier_hash(
-            DocumentType.FILE, file_name, search_space_id
+        # Generate unique identifier hash (uses file_id for Google Drive, filename for others)
+        primary_hash, legacy_hash = get_google_drive_unique_identifier(
+            connector, file_name, search_space_id
         )
 
         # Generate content hash
         content_hash = generate_content_hash(file_in_markdown, search_space_id)
 
-        # Check if document with this unique identifier already exists
-        existing_document = await check_document_by_unique_identifier(
-            session, unique_identifier_hash
+        # Check if document exists (with migration support for Google Drive and content_hash fallback)
+        existing_document = await find_existing_document_with_migration(
+            session, primary_hash, legacy_hash, content_hash
         )
 
         if existing_document:
-            # Document exists - check if content has changed
-            if existing_document.content_hash == content_hash:
-                logging.info(f"Document for file {file_name} unchanged. Skipping.")
-                return existing_document
-            else:
-                # Content has changed - update the existing document
-                logging.info(
-                    f"Content changed for file {file_name}. Updating document."
-                )
+            # Handle existing document (rename detection, content change check)
+            should_skip, doc = await handle_existing_document_update(
+                session,
+                existing_document,
+                content_hash,
+                connector,
+                file_name,
+                primary_hash,
+            )
+            if should_skip:
+                return doc
+            # Content changed - continue to update
 
         # Get user's long context LLM (needed for both create and update)
         user_llm = await get_user_long_context_llm(session, user_id, search_space_id)
@@ -379,10 +550,15 @@ async def add_received_file_document_using_llamacloud(
             document = existing_document
         else:
             # Create new document
+            # Determine document type based on connector
+            doc_type = DocumentType.FILE
+            if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+                doc_type = DocumentType.GOOGLE_DRIVE_FILE
+
             document = Document(
                 search_space_id=search_space_id,
                 title=file_name,
-                document_type=DocumentType.FILE,
+                document_type=doc_type,
                 document_metadata={
                     "FILE_NAME": file_name,
                     "ETL_SERVICE": "LLAMACLOUD",
@@ -391,7 +567,7 @@ async def add_received_file_document_using_llamacloud(
                 embedding=summary_embedding,
                 chunks=chunks,
                 content_hash=content_hash,
-                unique_identifier_hash=unique_identifier_hash,
+                unique_identifier_hash=primary_hash,
                 blocknote_document=blocknote_json,
                 content_needs_reindexing=False,
                 updated_at=get_current_timestamp(),
@@ -418,6 +594,7 @@ async def add_received_file_document_using_docling(
     docling_markdown_document: str,
     search_space_id: int,
     user_id: str,
+    connector: dict | None = None,
 ) -> Document | None:
     """
     Process and store document content parsed by Docling.
@@ -428,6 +605,7 @@ async def add_received_file_document_using_docling(
         docling_markdown_document: Markdown content from Docling parsing
         search_space_id: ID of the search space
         user_id: ID of the user
+        connector: Optional connector info for Google Drive files
 
     Returns:
         Document object if successful, None if failed
@@ -435,35 +613,38 @@ async def add_received_file_document_using_docling(
     try:
         file_in_markdown = docling_markdown_document
 
-        # Generate unique identifier hash for this file
-        unique_identifier_hash = generate_unique_identifier_hash(
-            DocumentType.FILE, file_name, search_space_id
+        # Generate unique identifier hash (uses file_id for Google Drive, filename for others)
+        primary_hash, legacy_hash = get_google_drive_unique_identifier(
+            connector, file_name, search_space_id
         )
 
         # Generate content hash
         content_hash = generate_content_hash(file_in_markdown, search_space_id)
 
-        # Check if document with this unique identifier already exists
-        existing_document = await check_document_by_unique_identifier(
-            session, unique_identifier_hash
+        # Check if document exists (with migration support for Google Drive and content_hash fallback)
+        existing_document = await find_existing_document_with_migration(
+            session, primary_hash, legacy_hash, content_hash
         )
 
         if existing_document:
-            # Document exists - check if content has changed
-            if existing_document.content_hash == content_hash:
-                logging.info(f"Document for file {file_name} unchanged. Skipping.")
-                return existing_document
-            else:
-                # Content has changed - update the existing document
-                logging.info(
-                    f"Content changed for file {file_name}. Updating document."
-                )
+            # Handle existing document (rename detection, content change check)
+            should_skip, doc = await handle_existing_document_update(
+                session,
+                existing_document,
+                content_hash,
+                connector,
+                file_name,
+                primary_hash,
+            )
+            if should_skip:
+                return doc
+            # Content changed - continue to update
 
         # Get user's long context LLM (needed for both create and update)
         user_llm = await get_user_long_context_llm(session, user_id, search_space_id)
         if not user_llm:
             raise RuntimeError(
-                f"No long context LLM configured for user {user_id} in search space {search_space_id}"
+                f"No long context LLM configured for user {user_id} in search_space {search_space_id}"
             )
 
         # Generate summary using chunked processing for large documents
@@ -533,10 +714,15 @@ async def add_received_file_document_using_docling(
             document = existing_document
         else:
             # Create new document
+            # Determine document type based on connector
+            doc_type = DocumentType.FILE
+            if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+                doc_type = DocumentType.GOOGLE_DRIVE_FILE
+
             document = Document(
                 search_space_id=search_space_id,
                 title=file_name,
-                document_type=DocumentType.FILE,
+                document_type=doc_type,
                 document_metadata={
                     "FILE_NAME": file_name,
                     "ETL_SERVICE": "DOCLING",
@@ -545,15 +731,15 @@ async def add_received_file_document_using_docling(
                 embedding=summary_embedding,
                 chunks=chunks,
                 content_hash=content_hash,
-                unique_identifier_hash=unique_identifier_hash,
+                unique_identifier_hash=primary_hash,
                 blocknote_document=blocknote_json,
                 content_needs_reindexing=False,
                 updated_at=get_current_timestamp(),
             )
 
-        session.add(document)
-        await session.commit()
-        await session.refresh(document)
+            session.add(document)
+            await session.commit()
+            await session.refresh(document)
 
         return document
     except SQLAlchemyError as db_error:
@@ -594,10 +780,23 @@ async def process_file_in_background(
     log_entry: Log,
     connector: dict
     | None = None,  # Optional: {"type": "GOOGLE_DRIVE_FILE", "metadata": {...}}
-):
+    notification: Notification
+    | None = None,  # Optional notification for progress updates
+) -> Document | None:
     try:
         # Check if the file is a markdown or text file
         if filename.lower().endswith((".md", ".markdown", ".txt")):
+            # Update notification: parsing stage
+            if notification:
+                await (
+                    NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="parsing",
+                        stage_message="Reading file",
+                    )
+                )
+
             await task_logger.log_task_progress(
                 log_entry,
                 f"Processing markdown/text file: {filename}",
@@ -617,6 +816,14 @@ async def process_file_in_background(
                 print("Error deleting temp file", e)
                 pass
 
+            # Update notification: chunking stage
+            if notification:
+                await (
+                    NotificationService.document_processing.notify_processing_progress(
+                        session, notification, stage="chunking"
+                    )
+                )
+
             await task_logger.log_task_progress(
                 log_entry,
                 f"Creating document from markdown content: {filename}",
@@ -628,7 +835,7 @@ async def process_file_in_background(
 
             # Process markdown directly through specialized function
             result = await add_received_markdown_file_document(
-                session, filename, markdown_content, search_space_id, user_id
+                session, filename, markdown_content, search_space_id, user_id, connector
             )
 
             if connector:
@@ -644,17 +851,30 @@ async def process_file_in_background(
                         "file_type": "markdown",
                     },
                 )
+                return result
             else:
                 await task_logger.log_task_success(
                     log_entry,
                     f"Markdown file already exists (duplicate): {filename}",
                     {"duplicate_detected": True, "file_type": "markdown"},
                 )
+                return None
 
         # Check if the file is an audio file
         elif filename.lower().endswith(
             (".mp3", ".mp4", ".mpeg", ".mpga", ".m4a", ".wav", ".webm")
         ):
+            # Update notification: parsing stage (transcription)
+            if notification:
+                await (
+                    NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="parsing",
+                        stage_message="Transcribing audio",
+                    )
+                )
+
             await task_logger.log_task_progress(
                 log_entry,
                 f"Processing audio file for transcription: {filename}",
@@ -738,6 +958,14 @@ async def process_file_in_background(
                 },
             )
 
+            # Update notification: chunking stage
+            if notification:
+                await (
+                    NotificationService.document_processing.notify_processing_progress(
+                        session, notification, stage="chunking"
+                    )
+                )
+
             # Clean up the temp file
             try:
                 os.unlink(file_path)
@@ -747,7 +975,7 @@ async def process_file_in_background(
 
             # Process transcription as markdown document
             result = await add_received_markdown_file_document(
-                session, filename, transcribed_text, search_space_id, user_id
+                session, filename, transcribed_text, search_space_id, user_id, connector
             )
 
             if connector:
@@ -765,12 +993,14 @@ async def process_file_in_background(
                         "stt_service": stt_service_type,
                     },
                 )
+                return result
             else:
                 await task_logger.log_task_success(
                     log_entry,
                     f"Audio file transcript already exists (duplicate): {filename}",
                     {"duplicate_detected": True, "file_type": "audio"},
                 )
+                return None
 
         else:
             # Import page limit service
@@ -835,6 +1065,15 @@ async def process_file_in_background(
                 ) from e
 
             if app_config.ETL_SERVICE == "UNSTRUCTURED":
+                # Update notification: parsing stage
+                if notification:
+                    await NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="parsing",
+                        stage_message="Extracting content",
+                    )
+
                 await task_logger.log_task_progress(
                     log_entry,
                     f"Processing file with Unstructured ETL: {filename}",
@@ -860,6 +1099,12 @@ async def process_file_in_background(
 
                 docs = await loader.aload()
 
+                # Update notification: chunking stage
+                if notification:
+                    await NotificationService.document_processing.notify_processing_progress(
+                        session, notification, stage="chunking", chunks_count=len(docs)
+                    )
+
                 await task_logger.log_task_progress(
                     log_entry,
                     f"Unstructured ETL completed, creating document: {filename}",
@@ -895,7 +1140,7 @@ async def process_file_in_background(
 
                 # Pass the documents to the existing background task
                 result = await add_received_file_document_using_unstructured(
-                    session, filename, docs, search_space_id, user_id
+                    session, filename, docs, search_space_id, user_id, connector
                 )
 
                 if connector:
@@ -919,6 +1164,7 @@ async def process_file_in_background(
                             "pages_processed": final_page_count,
                         },
                     )
+                    return result
                 else:
                     await task_logger.log_task_success(
                         log_entry,
@@ -929,8 +1175,18 @@ async def process_file_in_background(
                             "etl_service": "UNSTRUCTURED",
                         },
                     )
+                    return None
 
             elif app_config.ETL_SERVICE == "LLAMACLOUD":
+                # Update notification: parsing stage
+                if notification:
+                    await NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="parsing",
+                        stage_message="Extracting content",
+                    )
+
                 await task_logger.log_task_progress(
                     log_entry,
                     f"Processing file with LlamaCloud ETL: {filename}",
@@ -964,6 +1220,15 @@ async def process_file_in_background(
                     split_by_page=False
                 )
 
+                # Update notification: chunking stage
+                if notification:
+                    await NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="chunking",
+                        chunks_count=len(markdown_documents),
+                    )
+
                 await task_logger.log_task_progress(
                     log_entry,
                     f"LlamaCloud parsing completed, creating documents: {filename}",
@@ -1023,6 +1288,7 @@ async def process_file_in_background(
                         llamacloud_markdown_document=markdown_content,
                         search_space_id=search_space_id,
                         user_id=user_id,
+                        connector=connector,
                     )
 
                     # Track if this document was successfully created
@@ -1056,6 +1322,7 @@ async def process_file_in_background(
                             "documents_count": len(markdown_documents),
                         },
                     )
+                    return last_created_doc
                 else:
                     # All documents were duplicates (markdown_documents was not empty, but all returned None)
                     await task_logger.log_task_success(
@@ -1068,8 +1335,18 @@ async def process_file_in_background(
                             "documents_count": len(markdown_documents),
                         },
                     )
+                    return None
 
             elif app_config.ETL_SERVICE == "DOCLING":
+                # Update notification: parsing stage
+                if notification:
+                    await NotificationService.document_processing.notify_processing_progress(
+                        session,
+                        notification,
+                        stage="parsing",
+                        stage_message="Extracting content",
+                    )
+
                 await task_logger.log_task_progress(
                     log_entry,
                     f"Processing file with Docling ETL: {filename}",
@@ -1152,6 +1429,12 @@ async def process_file_in_background(
                         },
                     )
 
+                # Update notification: chunking stage
+                if notification:
+                    await NotificationService.document_processing.notify_processing_progress(
+                        session, notification, stage="chunking"
+                    )
+
                 # Process the document using our Docling background task
                 doc_result = await add_received_file_document_using_docling(
                     session,
@@ -1159,6 +1442,7 @@ async def process_file_in_background(
                     docling_markdown_document=result["content"],
                     search_space_id=search_space_id,
                     user_id=user_id,
+                    connector=connector,
                 )
 
                 if doc_result:
@@ -1184,6 +1468,7 @@ async def process_file_in_background(
                             "pages_processed": final_page_count,
                         },
                     )
+                    return doc_result
                 else:
                     await task_logger.log_task_success(
                         log_entry,
@@ -1194,6 +1479,7 @@ async def process_file_in_background(
                             "etl_service": "DOCLING",
                         },
                     )
+                    return None
     except Exception as e:
         await session.rollback()
 

surfsense_backend/app/tasks/document_processors/markdown_processor.py

@@ -19,16 +19,157 @@ from app.utils.document_converters import (
 
 from .base import (
     check_document_by_unique_identifier,
+    check_duplicate_document,
     get_current_timestamp,
 )
 
 
+def _get_google_drive_unique_identifier(
+    connector: dict | None,
+    filename: str,
+    search_space_id: int,
+) -> tuple[str, str | None]:
+    """
+    Get unique identifier hash for a file, with special handling for Google Drive.
+
+    For Google Drive files, uses file_id as the unique identifier (doesn't change on rename).
+    For other files, uses filename.
+
+    Args:
+        connector: Optional connector info dict with type and metadata
+        filename: The filename (used for non-Google Drive files or as fallback)
+        search_space_id: The search space ID
+
+    Returns:
+        Tuple of (primary_hash, legacy_hash or None)
+    """
+    if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+        metadata = connector.get("metadata", {})
+        file_id = metadata.get("google_drive_file_id")
+
+        if file_id:
+            primary_hash = generate_unique_identifier_hash(
+                DocumentType.GOOGLE_DRIVE_FILE, file_id, search_space_id
+            )
+            legacy_hash = generate_unique_identifier_hash(
+                DocumentType.GOOGLE_DRIVE_FILE, filename, search_space_id
+            )
+            return primary_hash, legacy_hash
+
+    primary_hash = generate_unique_identifier_hash(
+        DocumentType.FILE, filename, search_space_id
+    )
+    return primary_hash, None
+
+
+async def _find_existing_document_with_migration(
+    session: AsyncSession,
+    primary_hash: str,
+    legacy_hash: str | None,
+    content_hash: str | None = None,
+) -> Document | None:
+    """
+    Find existing document, checking both new hash and legacy hash for migration,
+    with fallback to content_hash for cross-source deduplication.
+    """
+    existing_document = await check_document_by_unique_identifier(session, primary_hash)
+
+    if not existing_document and legacy_hash:
+        existing_document = await check_document_by_unique_identifier(
+            session, legacy_hash
+        )
+        if existing_document:
+            logging.info(
+                "Found legacy document (filename-based hash), will migrate to file_id-based hash"
+            )
+
+    # Fallback: check by content_hash to catch duplicates from different sources
+    if not existing_document and content_hash:
+        existing_document = await check_duplicate_document(session, content_hash)
+        if existing_document:
+            logging.info(
+                f"Found duplicate content from different source (content_hash match). "
+                f"Original document ID: {existing_document.id}, type: {existing_document.document_type}"
+            )
+
+    return existing_document
+
+
+async def _handle_existing_document_update(
+    session: AsyncSession,
+    existing_document: Document,
+    content_hash: str,
+    connector: dict | None,
+    filename: str,
+    primary_hash: str,
+    task_logger: TaskLoggingService,
+    log_entry,
+) -> tuple[bool, Document | None]:
+    """
+    Handle update logic for an existing document.
+
+    Returns:
+        Tuple of (should_skip_processing, document_to_return)
+    """
+    # Check if this document needs hash migration
+    if existing_document.unique_identifier_hash != primary_hash:
+        existing_document.unique_identifier_hash = primary_hash
+        logging.info(f"Migrated document to file_id-based identifier: {filename}")
+
+    # Check if content has changed
+    if existing_document.content_hash == content_hash:
+        # Content unchanged - check if we need to update metadata (e.g., filename changed)
+        if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+            connector_metadata = connector.get("metadata", {})
+            new_name = connector_metadata.get("google_drive_file_name")
+            # Check both possible keys for old name (FILE_NAME is used in stored documents)
+            doc_metadata = existing_document.document_metadata or {}
+            old_name = (
+                doc_metadata.get("FILE_NAME")
+                or doc_metadata.get("google_drive_file_name")
+                or doc_metadata.get("file_name")
+            )
+
+            if new_name and old_name and old_name != new_name:
+                # File was renamed - update title and metadata, skip expensive processing
+                from sqlalchemy.orm.attributes import flag_modified
+
+                existing_document.title = new_name
+                if not existing_document.document_metadata:
+                    existing_document.document_metadata = {}
+                existing_document.document_metadata["FILE_NAME"] = new_name
+                existing_document.document_metadata["file_name"] = new_name
+                existing_document.document_metadata["google_drive_file_name"] = new_name
+                flag_modified(existing_document, "document_metadata")
+                await session.commit()
+                logging.info(
+                    f"File renamed in Google Drive: '{old_name}' → '{new_name}' (no re-processing needed)"
+                )
+
+        await task_logger.log_task_success(
+            log_entry,
+            f"Markdown file document unchanged: {filename}",
+            {
+                "duplicate_detected": True,
+                "existing_document_id": existing_document.id,
+            },
+        )
+        logging.info(f"Document for markdown file {filename} unchanged. Skipping.")
+        return True, existing_document
+    else:
+        logging.info(
+            f"Content changed for markdown file {filename}. Updating document."
+        )
+        return False, None
+
+
 async def add_received_markdown_file_document(
     session: AsyncSession,
     file_name: str,
     file_in_markdown: str,
     search_space_id: int,
     user_id: str,
+    connector: dict | None = None,
 ) -> Document | None:
     """
     Process and store a markdown file document.
@@ -39,6 +180,7 @@ async def add_received_markdown_file_document(
         file_in_markdown: Content of the markdown file
         search_space_id: ID of the search space
         user_id: ID of the user
+        connector: Optional connector info for Google Drive files
 
     Returns:
         Document object if successful, None if failed
@@ -58,39 +200,34 @@ async def add_received_markdown_file_document(
     )
 
     try:
-        # Generate unique identifier hash for this markdown file
-        unique_identifier_hash = generate_unique_identifier_hash(
-            DocumentType.FILE, file_name, search_space_id
+        # Generate unique identifier hash (uses file_id for Google Drive, filename for others)
+        primary_hash, legacy_hash = _get_google_drive_unique_identifier(
+            connector, file_name, search_space_id
         )
 
         # Generate content hash
         content_hash = generate_content_hash(file_in_markdown, search_space_id)
 
-        # Check if document with this unique identifier already exists
-        existing_document = await check_document_by_unique_identifier(
-            session, unique_identifier_hash
+        # Check if document exists (with migration support for Google Drive and content_hash fallback)
+        existing_document = await _find_existing_document_with_migration(
+            session, primary_hash, legacy_hash, content_hash
         )
 
         if existing_document:
-            # Document exists - check if content has changed
-            if existing_document.content_hash == content_hash:
-                await task_logger.log_task_success(
-                    log_entry,
-                    f"Markdown file document unchanged: {file_name}",
-                    {
-                        "duplicate_detected": True,
-                        "existing_document_id": existing_document.id,
-                    },
-                )
-                logging.info(
-                    f"Document for markdown file {file_name} unchanged. Skipping."
-                )
-                return existing_document
-            else:
-                # Content has changed - update the existing document
-                logging.info(
-                    f"Content changed for markdown file {file_name}. Updating document."
-                )
+            # Handle existing document (rename detection, content change check)
+            should_skip, doc = await _handle_existing_document_update(
+                session,
+                existing_document,
+                content_hash,
+                connector,
+                file_name,
+                primary_hash,
+                task_logger,
+                log_entry,
+            )
+            if should_skip:
+                return doc
+            # Content changed - continue to update
 
         # Get user's long context LLM (needed for both create and update)
         user_llm = await get_user_long_context_llm(session, user_id, search_space_id)
@@ -139,10 +276,15 @@ async def add_received_markdown_file_document(
             document = existing_document
         else:
             # Create new document
+            # Determine document type based on connector
+            doc_type = DocumentType.FILE
+            if connector and connector.get("type") == DocumentType.GOOGLE_DRIVE_FILE:
+                doc_type = DocumentType.GOOGLE_DRIVE_FILE
+
             document = Document(
                 search_space_id=search_space_id,
                 title=file_name,
-                document_type=DocumentType.FILE,
+                document_type=doc_type,
                 document_metadata={
                     "FILE_NAME": file_name,
                 },
@@ -150,7 +292,7 @@ async def add_received_markdown_file_document(
                 embedding=summary_embedding,
                 chunks=chunks,
                 content_hash=content_hash,
-                unique_identifier_hash=unique_identifier_hash,
+                unique_identifier_hash=primary_hash,
                 blocknote_document=blocknote_json,
                 updated_at=get_current_timestamp(),
             )

surfsense_backend/scripts/docker/entrypoint.sh

@@ -11,6 +11,26 @@ cleanup() {
 
 trap cleanup SIGTERM SIGINT
 
+# Run database migrations with safeguards
+echo "Running database migrations..."
+# Wait for database to be ready (max 30 seconds)
+for i in {1..30}; do
+    if python -c "from app.db import engine; import asyncio; asyncio.run(engine.dispose())" 2>/dev/null; then
+        echo "Database is ready."
+        break
+    fi
+    echo "Waiting for database... ($i/30)"
+    sleep 1
+done
+
+# Run migrations with timeout (60 seconds max)
+if timeout 60 alembic upgrade head 2>&1; then
+    echo "Migrations completed successfully."
+else
+    echo "WARNING: Migration failed or timed out. Continuing anyway..."
+    echo "You may need to run migrations manually: alembic upgrade head"
+fi
+
 echo "Starting FastAPI Backend..."
 python main.py &
 backend_pid=$!

surfsense_web/.env.example

@@ -1,5 +1,10 @@
 NEXT_PUBLIC_FASTAPI_BACKEND_URL=http://localhost:8000
 NEXT_PUBLIC_FASTAPI_BACKEND_AUTH_TYPE=LOCAL or GOOGLE
 NEXT_PUBLIC_ETL_SERVICE=UNSTRUCTURED or LLAMACLOUD or DOCLING
+
+# Electric SQL
+NEXT_PUBLIC_ELECTRIC_URL=http://localhost:5133
+NEXT_PUBLIC_ELECTRIC_AUTH_MODE=insecure
+
 # Contact Form Vars - OPTIONAL
 DATABASE_URL=postgresql://postgres:[YOUR-PASSWORD]@db.sdsf.supabase.co:5432/postgres

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/components/DocumentsTableShell.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { ChevronDown, ChevronUp, FileX, Plus } from "lucide-react";
+import { ChevronDown, ChevronUp, FileX, Loader2, Plus } from "lucide-react";
 import { motion } from "motion/react";
 import { useParams } from "next/navigation";
 import { useTranslations } from "next-intl";
@@ -114,7 +114,7 @@ export function DocumentsTableShell({
 			{loading ? (
 				<div className="flex h-[400px] w-full items-center justify-center">
 					<div className="flex flex-col items-center gap-2">
-						<div className="h-8 w-8 animate-spin rounded-full border-b-2 border-primary"></div>
+						<Loader2 className="h-8 w-8 animate-spin text-primary" />
 						<p className="text-sm text-muted-foreground">{t("loading")}</p>
 					</div>
 				</div>

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/components/ProcessingIndicator.tsx

@@ -1,44 +0,0 @@
-"use client";
-
-import { Loader2 } from "lucide-react";
-import { AnimatePresence, motion } from "motion/react";
-import { useTranslations } from "next-intl";
-import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
-
-interface ProcessingIndicatorProps {
-	documentProcessorTasksCount: number;
-}
-
-export function ProcessingIndicator({ documentProcessorTasksCount }: ProcessingIndicatorProps) {
-	const t = useTranslations("documents");
-
-	// Only show when there are document_processor tasks (uploads), not connector_indexing_task (periodic reindexing)
-	if (documentProcessorTasksCount === 0) return null;
-
-	return (
-		<AnimatePresence>
-			<motion.div
-				initial={{ opacity: 0, height: 0, marginBottom: 0 }}
-				animate={{ opacity: 1, height: "auto", marginBottom: 24 }}
-				exit={{ opacity: 0, height: 0, marginBottom: 0 }}
-				transition={{ duration: 0.3 }}
-			>
-				<Alert className="border-border bg-primary/5">
-					<div className="flex items-center gap-4">
-						<div className="flex h-10 w-10 items-center justify-center rounded-full bg-primary/10">
-							<Loader2 className="h-5 w-5 animate-spin text-primary" />
-						</div>
-						<div className="flex-1">
-							<AlertTitle className="text-primary font-semibold">
-								{t("processing_documents")}
-							</AlertTitle>
-							<AlertDescription className="text-muted-foreground">
-								{t("active_tasks_count", { count: documentProcessorTasksCount })}
-							</AlertDescription>
-						</div>
-					</div>
-				</Alert>
-			</motion.div>
-		</AnimatePresence>
-	);
-}

surfsense_web/app/dashboard/[search_space_id]/documents/(manage)/page.tsx

@@ -6,20 +6,18 @@ import { RefreshCw, SquarePlus, Upload } from "lucide-react";
 import { motion } from "motion/react";
 import { useParams, useRouter } from "next/navigation";
 import { useTranslations } from "next-intl";
-import { useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useId, useMemo, useState } from "react";
 import { toast } from "sonner";
 import { deleteDocumentMutationAtom } from "@/atoms/documents/document-mutation.atoms";
 import { documentTypeCountsAtom } from "@/atoms/documents/document-query.atoms";
 import { useDocumentUploadDialog } from "@/components/assistant-ui/document-upload-popup";
 import { Button } from "@/components/ui/button";
 import type { DocumentTypeEnum } from "@/contracts/types/document.types";
-import { useLogsSummary } from "@/hooks/use-logs";
 import { documentsApiService } from "@/lib/apis/documents-api.service";
 import { cacheKeys } from "@/lib/query-client/cache-keys";
 import { DocumentsFilters } from "./components/DocumentsFilters";
 import { DocumentsTableShell, type SortKey } from "./components/DocumentsTableShell";
 import { PaginationControls } from "./components/PaginationControls";
-import { ProcessingIndicator } from "./components/ProcessingIndicator";
 import type { ColumnVisibility } from "./components/types";
 
 function useDebounced<T>(value: T, delay = 250) {
@@ -109,6 +107,52 @@ export default function DocumentsTable() {
 		enabled: !!searchSpaceId && !!debouncedSearch.trim(),
 	});
 
+	// Determine if we should show SurfSense docs (when no type filter or SURFSENSE_DOCS is selected)
+	const showSurfsenseDocs =
+		activeTypes.length === 0 || activeTypes.includes("SURFSENSE_DOCS" as DocumentTypeEnum);
+
+	// Use query for fetching SurfSense docs
+	const {
+		data: surfsenseDocsResponse,
+		isLoading: isSurfsenseDocsLoading,
+		refetch: refetchSurfsenseDocs,
+	} = useQuery({
+		queryKey: ["surfsense-docs", debouncedSearch, pageIndex, pageSize],
+		queryFn: () =>
+			documentsApiService.getSurfsenseDocs({
+				queryParams: {
+					page: pageIndex,
+					page_size: pageSize,
+					title: debouncedSearch.trim() || undefined,
+				},
+			}),
+		staleTime: 3 * 60 * 1000, // 3 minutes
+		enabled: showSurfsenseDocs,
+	});
+
+	// Transform SurfSense docs to match the Document type
+	const surfsenseDocsAsDocuments: Document[] = useMemo(() => {
+		if (!surfsenseDocsResponse?.items) return [];
+		return surfsenseDocsResponse.items.map((doc) => ({
+			id: doc.id,
+			title: doc.title,
+			document_type: "SURFSENSE_DOCS",
+			document_metadata: { source: doc.source },
+			content: doc.content,
+			created_at: new Date().toISOString(),
+			search_space_id: -1, // Special value for global docs
+		}));
+	}, [surfsenseDocsResponse]);
+
+	// Merge type counts with SURFSENSE_DOCS count
+	const typeCounts = useMemo(() => {
+		const counts = { ...(rawTypeCounts || {}) };
+		if (surfsenseDocsResponse?.total) {
+			counts.SURFSENSE_DOCS = surfsenseDocsResponse.total;
+		}
+		return counts;
+	}, [rawTypeCounts, surfsenseDocsResponse?.total]);
+
 	// Extract documents and total based on search state
 	const documents = debouncedSearch.trim()
 		? searchResponse?.items || []
@@ -150,30 +194,6 @@ export default function DocumentsTable() {
 		}
 	}, [debouncedSearch, refetchSearch, refetchDocuments, t, isRefreshing]);
 
-	// Set up smart polling for active tasks - only polls when tasks are in progress
-	const { summary } = useLogsSummary(searchSpaceId, 24, {
-		enablePolling: true,
-		refetchInterval: 5000, // Poll every 5 seconds when tasks are active
-	});
-
-	// Filter active tasks to only include document_processor tasks (uploads via "add sources")
-	// Exclude connector_indexing_task tasks (periodic reindexing)
-	const documentProcessorTasks =
-		summary?.active_tasks.filter((task) => task.source === "document_processor") || [];
-	const documentProcessorTasksCount = documentProcessorTasks.length;
-
-	const activeTasksCount = summary?.active_tasks.length || 0;
-	const prevActiveTasksCount = useRef(activeTasksCount);
-
-	// Auto-refresh when a task finishes
-	useEffect(() => {
-		if (prevActiveTasksCount.current > activeTasksCount) {
-			// A task has finished!
-			refreshCurrentView();
-		}
-		prevActiveTasksCount.current = activeTasksCount;
-	}, [activeTasksCount, refreshCurrentView]);
-
 	// Create a delete function for single document deletion
 	const deleteDocument = useCallback(
 		async (id: number) => {
@@ -262,8 +282,6 @@ export default function DocumentsTable() {
 				</div>
 			</motion.div>
 
-			<ProcessingIndicator documentProcessorTasksCount={documentProcessorTasksCount} />
-
 			<DocumentsFilters
 				typeCounts={rawTypeCounts ?? {}}
 				selectedIds={selectedIds}

surfsense_web/app/dashboard/[search_space_id]/editor/[documentId]/page.tsx

@@ -438,9 +438,7 @@ export default function EditorPage() {
 						{saving ? (
 							<>
 								<Loader2 className="h-3.5 w-3.5 md:h-4 md:w-4 animate-spin" />
-								<span className="text-xs md:text-sm">
-									{isNewNote ? "Creating..." : "Saving..."}
-								</span>
+								<span className="text-xs md:text-sm">{isNewNote ? "Creating" : "Saving"}</span>
 							</>
 						) : (
 							<>

surfsense_web/app/dashboard/[search_space_id]/team/page.tsx

@@ -1294,7 +1294,7 @@ function CreateInviteDialog({
 								{creating ? (
 									<>
 										<Loader2 className="h-4 w-4 mr-2 animate-spin" />
-										Creating...
+										Creating
 									</>
 								) : (
 									"Create Invite"
@@ -1471,7 +1471,7 @@ function CreateRoleDialog({
 						{creating ? (
 							<>
 								<Loader2 className="h-4 w-4 mr-2 animate-spin" />
-								Creating...
+								Creating
 							</>
 						) : (
 							"Create Role"

surfsense_web/app/layout.tsx

@@ -2,6 +2,7 @@ import type { Metadata } from "next";
 import "./globals.css";
 import { RootProvider } from "fumadocs-ui/provider/next";
 import { Roboto } from "next/font/google";
+import { ElectricProvider } from "@/components/providers/ElectricProvider";
 import { I18nProvider } from "@/components/providers/I18nProvider";
 import { PostHogProvider } from "@/components/providers/PostHogProvider";
 import { ThemeProvider } from "@/components/theme/theme-provider";
@@ -102,7 +103,9 @@ export default function RootLayout({
 								defaultTheme="light"
 							>
 								<RootProvider>
-									<ReactQueryClientProvider>{children}</ReactQueryClientProvider>
+									<ReactQueryClientProvider>
+										<ElectricProvider>{children}</ElectricProvider>
+									</ReactQueryClientProvider>
 									<Toaster />
 								</RootProvider>
 							</ThemeProvider>

surfsense_web/components/UserDropdown.tsx

@@ -13,6 +13,7 @@ import {
 	DropdownMenuSeparator,
 	DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
+import { cleanupElectric } from "@/lib/electric/client";
 import { resetUser, trackLogout } from "@/lib/posthog/events";
 
 export function UserDropdown({
@@ -26,12 +27,20 @@ export function UserDropdown({
 }) {
 	const router = useRouter();
 
-	const handleLogout = () => {
+	const handleLogout = async () => {
 		try {
 			// Track logout event and reset PostHog identity
 			trackLogout();
 			resetUser();
 
+			// Best-effort cleanup of Electric SQL / PGlite
+			// Even if this fails, login-time cleanup will handle it
+			try {
+				await cleanupElectric();
+			} catch (err) {
+				console.warn("[Logout] Electric cleanup failed (will be handled on next login):", err);
+			}
+
 			if (typeof window !== "undefined") {
 				localStorage.removeItem("surfsense_bearer_token");
 				window.location.href = "/";
@@ -40,7 +49,7 @@ export function UserDropdown({
 			console.error("Error during logout:", error);
 			// Optionally, provide user feedback
 			if (typeof window !== "undefined") {
-				alert("Logout failed. Please try again.");
+				localStorage.removeItem("surfsense_bearer_token");
 				window.location.href = "/";
 			}
 		}

surfsense_web/components/assistant-ui/attachment.tsx

@@ -357,7 +357,7 @@ export const ComposerAddAttachment: FC = () => {
 					</DropdownMenuItem>
 					<DropdownMenuItem onClick={handleFileUpload} className="cursor-pointer">
 						<Upload className="size-4" />
-						<span>Upload Files</span>
+						<span>Upload Documents</span>
 					</DropdownMenuItem>
 				</DropdownMenuContent>
 			</DropdownMenu>

surfsense_web/components/assistant-ui/composer-action.tsx

@@ -1,300 +0,0 @@
-import { AssistantIf, ComposerPrimitive, useAssistantState } from "@assistant-ui/react";
-import { useAtomValue } from "jotai";
-import {
-	AlertCircle,
-	ArrowUpIcon,
-	ChevronRightIcon,
-	Loader2,
-	Plug2,
-	Plus,
-	SquareIcon,
-} from "lucide-react";
-import type { FC } from "react";
-import { useCallback, useMemo, useRef, useState } from "react";
-import { getDocumentTypeLabel } from "@/app/dashboard/[search_space_id]/documents/(manage)/components/DocumentTypeIcon";
-import { documentTypeCountsAtom } from "@/atoms/documents/document-query.atoms";
-import {
-	globalNewLLMConfigsAtom,
-	llmPreferencesAtom,
-	newLLMConfigsAtom,
-} from "@/atoms/new-llm-config/new-llm-config-query.atoms";
-import { activeSearchSpaceIdAtom } from "@/atoms/search-spaces/search-space-query.atoms";
-import { ComposerAddAttachment } from "@/components/assistant-ui/attachment";
-import { TooltipIconButton } from "@/components/assistant-ui/tooltip-icon-button";
-import { Button } from "@/components/ui/button";
-import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
-import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
-import { useSearchSourceConnectors } from "@/hooks/use-search-source-connectors";
-import { cn } from "@/lib/utils";
-
-const ConnectorIndicator: FC = () => {
-	const searchSpaceId = useAtomValue(activeSearchSpaceIdAtom);
-	const { connectors, isLoading: connectorsLoading } = useSearchSourceConnectors(
-		false,
-		searchSpaceId ? Number(searchSpaceId) : undefined
-	);
-	const { data: documentTypeCounts, isLoading: documentTypesLoading } =
-		useAtomValue(documentTypeCountsAtom);
-	const [isOpen, setIsOpen] = useState(false);
-	const closeTimeoutRef = useRef<NodeJS.Timeout | null>(null);
-
-	const isLoading = connectorsLoading || documentTypesLoading;
-
-	const activeDocumentTypes = documentTypeCounts
-		? Object.entries(documentTypeCounts).filter(([_, count]) => count > 0)
-		: [];
-
-	// Count only active connectors (matching what's shown in the Active tab)
-	const activeConnectorsCount = connectors.length;
-	const hasConnectors = activeConnectorsCount > 0;
-	const hasSources = hasConnectors || activeDocumentTypes.length > 0;
-
-	const handleMouseEnter = useCallback(() => {
-		// Clear any pending close timeout
-		if (closeTimeoutRef.current) {
-			clearTimeout(closeTimeoutRef.current);
-			closeTimeoutRef.current = null;
-		}
-		setIsOpen(true);
-	}, []);
-
-	const handleMouseLeave = useCallback(() => {
-		// Delay closing by 150ms for better UX
-		closeTimeoutRef.current = setTimeout(() => {
-			setIsOpen(false);
-		}, 150);
-	}, []);
-
-	if (!searchSpaceId) return null;
-
-	return (
-		<Popover open={isOpen} onOpenChange={setIsOpen}>
-			<PopoverTrigger asChild>
-				<button
-					type="button"
-					className={cn(
-						"size-[34px] rounded-full p-1 flex items-center justify-center transition-colors relative",
-						"hover:bg-muted-foreground/15 dark:hover:bg-muted-foreground/30",
-						"outline-none focus:outline-none focus-visible:outline-none",
-						"border-0 ring-0 focus:ring-0 shadow-none focus:shadow-none",
-						"data-[state=open]:bg-transparent data-[state=open]:shadow-none data-[state=open]:ring-0",
-						"text-muted-foreground"
-					)}
-					aria-label={
-						hasConnectors
-							? `View ${activeConnectorsCount} active connectors`
-							: "Add your first connector"
-					}
-					onMouseEnter={handleMouseEnter}
-					onMouseLeave={handleMouseLeave}
-				>
-					{isLoading ? (
-						<Loader2 className="size-4 animate-spin" />
-					) : (
-						<>
-							<Plug2 className="size-4" />
-							{activeConnectorsCount > 0 && (
-								<span className="absolute -top-0.5 -right-0.5 flex items-center justify-center min-w-[16px] h-4 px-1 text-[10px] font-medium rounded-full bg-primary text-primary-foreground shadow-sm">
-									{activeConnectorsCount > 99 ? "99+" : activeConnectorsCount}
-								</span>
-							)}
-						</>
-					)}
-				</button>
-			</PopoverTrigger>
-			<PopoverContent
-				side="bottom"
-				align="start"
-				className="w-64 p-3"
-				onMouseEnter={handleMouseEnter}
-				onMouseLeave={handleMouseLeave}
-			>
-				{hasSources ? (
-					<div className="space-y-3">
-						{activeConnectorsCount > 0 && (
-							<div className="flex items-center justify-between">
-								<p className="text-xs font-medium text-muted-foreground">Active Connectors</p>
-								<span className="text-xs font-medium bg-muted px-1.5 py-0.5 rounded">
-									{activeConnectorsCount}
-								</span>
-							</div>
-						)}
-						{activeConnectorsCount > 0 && (
-							<div className="flex flex-wrap gap-2">
-								{connectors.map((connector) => (
-									<div
-										key={`connector-${connector.id}`}
-										className="flex items-center gap-1.5 rounded-md bg-muted/80 px-2.5 py-1.5 text-xs border border-border/50"
-									>
-										{getConnectorIcon(connector.connector_type, "size-3.5")}
-										<span className="truncate max-w-[100px]">{connector.name}</span>
-									</div>
-								))}
-							</div>
-						)}
-						{activeDocumentTypes.length > 0 && (
-							<>
-								{activeConnectorsCount > 0 && (
-									<div className="pt-2 border-t border-border/50">
-										<p className="text-xs font-medium text-muted-foreground mb-2">Documents</p>
-									</div>
-								)}
-								<div className="flex flex-wrap gap-2">
-									{activeDocumentTypes.map(([docType, count]) => (
-										<div
-											key={docType}
-											className="flex items-center gap-1.5 rounded-md bg-muted/80 px-2.5 py-1.5 text-xs border border-border/50"
-										>
-											{getConnectorIcon(docType, "size-3.5")}
-											<span className="truncate max-w-[100px]">
-												{getDocumentTypeLabel(docType)}
-											</span>
-											<span className="flex items-center justify-center min-w-[18px] h-[18px] px-1 text-[10px] font-medium rounded-full bg-primary/10 text-primary">
-												{count > 999 ? "999+" : count}
-											</span>
-										</div>
-									))}
-								</div>
-							</>
-						)}
-						<div className="pt-1 border-t border-border/50">
-							<button
-								type="button"
-								className="inline-flex items-center gap-1.5 text-xs text-muted-foreground hover:text-foreground transition-colors"
-								onClick={() => {
-									/* Connector popup should be opened via the connector indicator button */
-								}}
-							>
-								<Plus className="size-3" />
-								Add more sources
-								<ChevronRightIcon className="size-3" />
-							</button>
-						</div>
-					</div>
-				) : (
-					<div className="space-y-2">
-						<p className="text-sm font-medium">No sources yet</p>
-						<p className="text-xs text-muted-foreground">
-							Add documents or connect data sources to enhance search results.
-						</p>
-						<button
-							type="button"
-							className="inline-flex items-center gap-1.5 rounded-md bg-primary px-3 py-1.5 text-xs font-medium text-primary-foreground hover:bg-primary/90 transition-colors mt-1"
-							onClick={() => {
-								/* Connector popup should be opened via the connector indicator button */
-							}}
-						>
-							<Plus className="size-3" />
-							Add Connector
-						</button>
-					</div>
-				)}
-			</PopoverContent>
-		</Popover>
-	);
-};
-
-export const ComposerAction: FC = () => {
-	// Check if any attachments are still being processed (running AND progress < 100)
-	// When progress is 100, processing is done but waiting for send()
-	const hasProcessingAttachments = useAssistantState(({ composer }) =>
-		composer.attachments?.some((att) => {
-			const status = att.status;
-			if (status?.type !== "running") return false;
-			const progress = (status as { type: "running"; progress?: number }).progress;
-			return progress === undefined || progress < 100;
-		})
-	);
-
-	// Check if composer text is empty
-	const isComposerEmpty = useAssistantState(({ composer }) => {
-		const text = composer.text?.trim() || "";
-		return text.length === 0;
-	});
-
-	// Check if a model is configured
-	const { data: userConfigs } = useAtomValue(newLLMConfigsAtom);
-	const { data: globalConfigs } = useAtomValue(globalNewLLMConfigsAtom);
-	const { data: preferences } = useAtomValue(llmPreferencesAtom);
-
-	const hasModelConfigured = useMemo(() => {
-		if (!preferences) return false;
-		const agentLlmId = preferences.agent_llm_id;
-		if (agentLlmId === null || agentLlmId === undefined) return false;
-
-		// Check if the configured model actually exists
-		if (agentLlmId < 0) {
-			return globalConfigs?.some((c) => c.id === agentLlmId) ?? false;
-		}
-		return userConfigs?.some((c) => c.id === agentLlmId) ?? false;
-	}, [preferences, globalConfigs, userConfigs]);
-
-	const isSendDisabled = hasProcessingAttachments || isComposerEmpty || !hasModelConfigured;
-
-	return (
-		<div className="aui-composer-action-wrapper relative mx-2 mb-2 flex items-center justify-between">
-			<div className="flex items-center gap-1">
-				<ComposerAddAttachment />
-				<ConnectorIndicator />
-			</div>
-
-			{/* Show processing indicator when attachments are being processed */}
-			{hasProcessingAttachments && (
-				<div className="flex items-center gap-1.5 text-muted-foreground text-xs">
-					<Loader2 className="size-3 animate-spin" />
-					<span>Processing...</span>
-				</div>
-			)}
-
-			{/* Show warning when no model is configured */}
-			{!hasModelConfigured && !hasProcessingAttachments && (
-				<div className="flex items-center gap-1.5 text-amber-600 dark:text-amber-400 text-xs">
-					<AlertCircle className="size-3" />
-					<span>Select a model</span>
-				</div>
-			)}
-
-			<AssistantIf condition={({ thread }) => !thread.isRunning}>
-				<ComposerPrimitive.Send asChild disabled={isSendDisabled}>
-					<TooltipIconButton
-						tooltip={
-							!hasModelConfigured
-								? "Please select a model from the header to start chatting"
-								: hasProcessingAttachments
-									? "Wait for attachments to process"
-									: isComposerEmpty
-										? "Enter a message to send"
-										: "Send message"
-						}
-						side="bottom"
-						type="submit"
-						variant="default"
-						size="icon"
-						className={cn(
-							"aui-composer-send size-8 rounded-full",
-							isSendDisabled && "cursor-not-allowed opacity-50"
-						)}
-						aria-label="Send message"
-						disabled={isSendDisabled}
-					>
-						<ArrowUpIcon className="aui-composer-send-icon size-4" />
-					</TooltipIconButton>
-				</ComposerPrimitive.Send>
-			</AssistantIf>
-
-			<AssistantIf condition={({ thread }) => thread.isRunning}>
-				<ComposerPrimitive.Cancel asChild>
-					<Button
-						type="button"
-						variant="default"
-						size="icon"
-						className="aui-composer-cancel size-8 rounded-full"
-						aria-label="Stop generating"
-					>
-						<SquareIcon className="aui-composer-cancel-icon size-3 fill-current" />
-					</Button>
-				</ComposerPrimitive.Cancel>
-			</AssistantIf>
-		</div>
-	);
-};

surfsense_web/components/assistant-ui/composer.tsx

@@ -1,257 +0,0 @@
-import { ComposerPrimitive, useAssistantState, useComposerRuntime } from "@assistant-ui/react";
-import { useAtom, useSetAtom } from "jotai";
-import { useParams } from "next/navigation";
-import type { FC } from "react";
-import { useCallback, useEffect, useRef, useState } from "react";
-import { createPortal } from "react-dom";
-import {
-	mentionedDocumentIdsAtom,
-	mentionedDocumentsAtom,
-} from "@/atoms/chat/mentioned-documents.atom";
-import { ComposerAddAttachment, ComposerAttachments } from "@/components/assistant-ui/attachment";
-import { ComposerAction } from "@/components/assistant-ui/composer-action";
-import {
-	InlineMentionEditor,
-	type InlineMentionEditorRef,
-} from "@/components/assistant-ui/inline-mention-editor";
-import {
-	DocumentMentionPicker,
-	type DocumentMentionPickerRef,
-} from "@/components/new-chat/document-mention-picker";
-import type { Document } from "@/contracts/types/document.types";
-
-export const Composer: FC = () => {
-	// ---- State for document mentions (using atoms to persist across remounts) ----
-	const [mentionedDocuments, setMentionedDocuments] = useAtom(mentionedDocumentsAtom);
-	const [showDocumentPopover, setShowDocumentPopover] = useState(false);
-	const [mentionQuery, setMentionQuery] = useState("");
-	const editorRef = useRef<InlineMentionEditorRef>(null);
-	const editorContainerRef = useRef<HTMLDivElement>(null);
-	const documentPickerRef = useRef<DocumentMentionPickerRef>(null);
-	const { search_space_id } = useParams();
-	const setMentionedDocumentIds = useSetAtom(mentionedDocumentIdsAtom);
-	const composerRuntime = useComposerRuntime();
-	const hasAutoFocusedRef = useRef(false);
-
-	// Check if thread is empty (new chat)
-	const isThreadEmpty = useAssistantState(({ thread }) => thread.isEmpty);
-
-	// Check if thread is currently running (streaming response)
-	const isThreadRunning = useAssistantState(({ thread }) => thread.isRunning);
-
-	// Auto-focus editor when on new chat page
-	useEffect(() => {
-		if (isThreadEmpty && !hasAutoFocusedRef.current && editorRef.current) {
-			// Small delay to ensure the editor is fully mounted
-			const timeoutId = setTimeout(() => {
-				editorRef.current?.focus();
-				hasAutoFocusedRef.current = true;
-			}, 100);
-			return () => clearTimeout(timeoutId);
-		}
-	}, [isThreadEmpty]);
-
-	// Sync mentioned document IDs to atom for use in chat request
-	useEffect(() => {
-		setMentionedDocumentIds({
-			surfsense_doc_ids: mentionedDocuments
-				.filter((doc) => doc.document_type === "SURFSENSE_DOCS")
-				.map((doc) => doc.id),
-			document_ids: mentionedDocuments
-				.filter((doc) => doc.document_type !== "SURFSENSE_DOCS")
-				.map((doc) => doc.id),
-		});
-	}, [mentionedDocuments, setMentionedDocumentIds]);
-
-	// Handle text change from inline editor - sync with assistant-ui composer
-	const handleEditorChange = useCallback(
-		(text: string) => {
-			composerRuntime.setText(text);
-		},
-		[composerRuntime]
-	);
-
-	// Handle @ mention trigger from inline editor
-	const handleMentionTrigger = useCallback((query: string) => {
-		setShowDocumentPopover(true);
-		setMentionQuery(query);
-	}, []);
-
-	// Handle mention close
-	const handleMentionClose = useCallback(() => {
-		if (showDocumentPopover) {
-			setShowDocumentPopover(false);
-			setMentionQuery("");
-		}
-	}, [showDocumentPopover]);
-
-	// Handle keyboard navigation when popover is open
-	const handleKeyDown = useCallback(
-		(e: React.KeyboardEvent) => {
-			if (showDocumentPopover) {
-				if (e.key === "ArrowDown") {
-					e.preventDefault();
-					documentPickerRef.current?.moveDown();
-					return;
-				}
-				if (e.key === "ArrowUp") {
-					e.preventDefault();
-					documentPickerRef.current?.moveUp();
-					return;
-				}
-				if (e.key === "Enter") {
-					e.preventDefault();
-					documentPickerRef.current?.selectHighlighted();
-					return;
-				}
-				if (e.key === "Escape") {
-					e.preventDefault();
-					setShowDocumentPopover(false);
-					setMentionQuery("");
-					return;
-				}
-			}
-		},
-		[showDocumentPopover]
-	);
-
-	// Handle submit from inline editor (Enter key)
-	const handleSubmit = useCallback(() => {
-		// Prevent sending while a response is still streaming
-		if (isThreadRunning) {
-			return;
-		}
-		if (!showDocumentPopover) {
-			composerRuntime.send();
-			// Clear the editor after sending
-			editorRef.current?.clear();
-			setMentionedDocuments([]);
-			setMentionedDocumentIds({
-				surfsense_doc_ids: [],
-				document_ids: [],
-			});
-		}
-	}, [
-		showDocumentPopover,
-		isThreadRunning,
-		composerRuntime,
-		setMentionedDocuments,
-		setMentionedDocumentIds,
-	]);
-
-	const handleDocumentRemove = useCallback(
-		(docId: number, docType?: string) => {
-			setMentionedDocuments((prev) => {
-				const updated = prev.filter((doc) => !(doc.id === docId && doc.document_type === docType));
-				setMentionedDocumentIds({
-					surfsense_doc_ids: updated
-						.filter((doc) => doc.document_type === "SURFSENSE_DOCS")
-						.map((doc) => doc.id),
-					document_ids: updated
-						.filter((doc) => doc.document_type !== "SURFSENSE_DOCS")
-						.map((doc) => doc.id),
-				});
-				return updated;
-			});
-		},
-		[setMentionedDocuments, setMentionedDocumentIds]
-	);
-
-	const handleDocumentsMention = useCallback(
-		(documents: Pick<Document, "id" | "title" | "document_type">[]) => {
-			const existingKeys = new Set(mentionedDocuments.map((d) => `${d.document_type}:${d.id}`));
-			const newDocs = documents.filter(
-				(doc) => !existingKeys.has(`${doc.document_type}:${doc.id}`)
-			);
-
-			for (const doc of newDocs) {
-				editorRef.current?.insertDocumentChip(doc);
-			}
-
-			setMentionedDocuments((prev) => {
-				const existingKeySet = new Set(prev.map((d) => `${d.document_type}:${d.id}`));
-				const uniqueNewDocs = documents.filter(
-					(doc) => !existingKeySet.has(`${doc.document_type}:${doc.id}`)
-				);
-				const updated = [...prev, ...uniqueNewDocs];
-				setMentionedDocumentIds({
-					surfsense_doc_ids: updated
-						.filter((doc) => doc.document_type === "SURFSENSE_DOCS")
-						.map((doc) => doc.id),
-					document_ids: updated
-						.filter((doc) => doc.document_type !== "SURFSENSE_DOCS")
-						.map((doc) => doc.id),
-				});
-				return updated;
-			});
-
-			setMentionQuery("");
-		},
-		[mentionedDocuments, setMentionedDocuments, setMentionedDocumentIds]
-	);
-
-	return (
-		<ComposerPrimitive.Root className="aui-composer-root relative flex w-full flex-col">
-			<ComposerPrimitive.AttachmentDropzone className="aui-composer-attachment-dropzone flex w-full flex-col rounded-2xl border-input bg-muted px-1 pt-2 outline-none transition-shadow data-[dragging=true]:border-ring data-[dragging=true]:border-dashed data-[dragging=true]:bg-accent/50">
-				<ComposerAttachments />
-				{/* -------- Inline Mention Editor -------- */}
-				<div ref={editorContainerRef} className="aui-composer-input-wrapper px-3 pt-3 pb-6">
-					<InlineMentionEditor
-						ref={editorRef}
-						placeholder="Ask SurfSense or @mention docs"
-						onMentionTrigger={handleMentionTrigger}
-						onMentionClose={handleMentionClose}
-						onChange={handleEditorChange}
-						onDocumentRemove={handleDocumentRemove}
-						onSubmit={handleSubmit}
-						onKeyDown={handleKeyDown}
-						className="min-h-[24px]"
-					/>
-				</div>
-
-				{/* -------- Document mention popover (rendered via portal) -------- */}
-				{showDocumentPopover &&
-					typeof document !== "undefined" &&
-					createPortal(
-						<>
-							{/* Backdrop */}
-							<button
-								type="button"
-								className="fixed inset-0 cursor-default"
-								style={{ zIndex: 9998 }}
-								onClick={() => setShowDocumentPopover(false)}
-								aria-label="Close document picker"
-							/>
-							{/* Popover positioned above input */}
-							<div
-								className="fixed shadow-2xl rounded-lg border border-border overflow-hidden bg-popover"
-								style={{
-									zIndex: 9999,
-									bottom: editorContainerRef.current
-										? `${window.innerHeight - editorContainerRef.current.getBoundingClientRect().top + 8}px`
-										: "200px",
-									left: editorContainerRef.current
-										? `${editorContainerRef.current.getBoundingClientRect().left}px`
-										: "50%",
-								}}
-							>
-								<DocumentMentionPicker
-									ref={documentPickerRef}
-									searchSpaceId={Number(search_space_id)}
-									onSelectionChange={handleDocumentsMention}
-									onDone={() => {
-										setShowDocumentPopover(false);
-										setMentionQuery("");
-									}}
-									initialSelectedDocuments={mentionedDocuments}
-									externalSearch={mentionQuery}
-								/>
-							</div>
-						</>,
-						document.body
-					)}
-				<ComposerAction />
-			</ComposerPrimitive.AttachmentDropzone>
-		</ComposerPrimitive.Root>
-	);
-};

surfsense_web/components/assistant-ui/connector-popup.tsx

@@ -1,19 +1,16 @@
 "use client";
 
-import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useAtomValue } from "jotai";
 import { Cable, Loader2 } from "lucide-react";
 import { useSearchParams } from "next/navigation";
-import { type FC, useEffect, useMemo } from "react";
-import { documentTypeCountsAtom } from "@/atoms/documents/document-query.atoms";
+import type { FC } from "react";
 import { activeSearchSpaceIdAtom } from "@/atoms/search-spaces/search-space-query.atoms";
 import { TooltipIconButton } from "@/components/assistant-ui/tooltip-icon-button";
 import { Dialog, DialogContent } from "@/components/ui/dialog";
 import { Tabs, TabsContent } from "@/components/ui/tabs";
 import type { SearchSourceConnector } from "@/contracts/types/connector.types";
-import { useLogsSummary } from "@/hooks/use-logs";
-import { connectorsApiService } from "@/lib/apis/connectors-api.service";
-import { cacheKeys } from "@/lib/query-client/cache-keys";
+import { useConnectorsElectric } from "@/hooks/use-connectors-electric";
+import { useDocumentsElectric } from "@/hooks/use-documents-electric";
 import { cn } from "@/lib/utils";
 import { ConnectorDialogHeader } from "./connector-popup/components/connector-dialog-header";
 import { ConnectorConnectView } from "./connector-popup/connector-configs/views/connector-connect-view";
@@ -21,26 +18,23 @@ import { ConnectorEditView } from "./connector-popup/connector-configs/views/con
 import { IndexingConfigurationView } from "./connector-popup/connector-configs/views/indexing-configuration-view";
 import { OAUTH_CONNECTORS } from "./connector-popup/constants/connector-constants";
 import { useConnectorDialog } from "./connector-popup/hooks/use-connector-dialog";
+import { useIndexingConnectors } from "./connector-popup/hooks/use-indexing-connectors";
 import { ActiveConnectorsTab } from "./connector-popup/tabs/active-connectors-tab";
 import { AllConnectorsTab } from "./connector-popup/tabs/all-connectors-tab";
 import { ConnectorAccountsListView } from "./connector-popup/views/connector-accounts-list-view";
+import { MCPConnectorListView } from "./connector-popup/views/mcp-connector-list-view";
 import { YouTubeCrawlerView } from "./connector-popup/views/youtube-crawler-view";
 
 export const ConnectorIndicator: FC = () => {
 	const searchSpaceId = useAtomValue(activeSearchSpaceIdAtom);
 	const searchParams = useSearchParams();
-	const { data: documentTypeCounts, isLoading: documentTypesLoading } =
-		useAtomValue(documentTypeCountsAtom);
+
+	// Fetch document type counts using Electric SQL + PGlite for real-time updates
+	const { documentTypeCounts, loading: documentTypesLoading } = useDocumentsElectric(searchSpaceId);
 
 	// Check if YouTube view is active
 	const isYouTubeView = searchParams.get("view") === "youtube";
 
-	// Track active indexing tasks
-	const { summary: logsSummary } = useLogsSummary(searchSpaceId ? Number(searchSpaceId) : 0, 24, {
-		enablePolling: true,
-		refetchInterval: 5000,
-	});
-
 	// Use the custom hook for dialog state management
 	const {
 		isOpen,
@@ -63,6 +57,7 @@ export const ConnectorIndicator: FC = () => {
 		frequencyMinutes,
 		allConnectors,
 		viewingAccountsType,
+		viewingMCPList,
 		setSearchQuery,
 		setStartDate,
 		setEndDate,
@@ -86,6 +81,8 @@ export const ConnectorIndicator: FC = () => {
 		handleBackFromYouTube,
 		handleViewAccountsList,
 		handleBackFromAccountsList,
+		handleBackFromMCPList,
+		handleAddNewMCPFromList,
 		handleQuickIndexConnector,
 		connectorConfig,
 		setConnectorConfig,
@@ -93,57 +90,35 @@ export const ConnectorIndicator: FC = () => {
 		setConnectorName,
 	} = useConnectorDialog();
 
-	// Fetch connectors using React Query with conditional refetchInterval
-	// This automatically refetches when mutations invalidate the cache (event-driven)
-	// and also polls when dialog is open to catch external changes
+	// Fetch connectors using Electric SQL + PGlite for real-time updates
+	// This provides instant updates when connectors change, without polling
 	const {
-		data: connectors = [],
-		isLoading: connectorsLoading,
-		refetch: refreshConnectors,
-	} = useQuery({
-		queryKey: cacheKeys.connectors.all(searchSpaceId || ""),
-		queryFn: () =>
-			connectorsApiService.getConnectors({
-				queryParams: {
-					search_space_id: searchSpaceId ? Number(searchSpaceId) : undefined,
-				},
-			}),
-		enabled: !!searchSpaceId,
-		staleTime: 5 * 60 * 1000, // 5 minutes (same as connectorsAtom)
-		// Poll when dialog is open to catch external changes
-		refetchInterval: isOpen ? 5000 : false, // 5 seconds when open, no polling when closed
-	});
+		connectors: connectorsFromElectric = [],
+		loading: connectorsLoading,
+		error: connectorsError,
+		refreshConnectors: refreshConnectorsElectric,
+	} = useConnectorsElectric(searchSpaceId);
 
-	const queryClient = useQueryClient();
+	// Fallback to API if Electric is not available or fails
+	// Use Electric data if: 1) we have data, or 2) still loading without error
+	// Use API data if: Electric failed (has error) or finished loading with no data
+	const useElectricData = connectorsFromElectric.length > 0 || (connectorsLoading && !connectorsError);
+	const connectors = useElectricData ? connectorsFromElectric : allConnectors || [];
 
-	// Also refresh document type counts when dialog is open
-	useEffect(() => {
-		if (!isOpen || !searchSpaceId) return;
+	// Manual refresh function that works with both Electric and API
+	const refreshConnectors = async () => {
+		if (useElectricData) {
+			await refreshConnectorsElectric();
+		} else {
+			// Fallback: use allConnectors from useConnectorDialog (which uses connectorsAtom)
+			// The connectorsAtom will handle refetching if needed
+		}
+	};
 
-		const POLL_INTERVAL = 5000; // 5 seconds, same as connectors
-
-		const intervalId = setInterval(() => {
-			// Invalidate document type counts to refresh active document types
-			queryClient.invalidateQueries({
-				queryKey: cacheKeys.documents.typeCounts(searchSpaceId),
-			});
-		}, POLL_INTERVAL);
-
-		// Cleanup interval on unmount or when dialog closes
-		return () => {
-			clearInterval(intervalId);
-		};
-	}, [isOpen, searchSpaceId, queryClient]);
-
-	// Get connector IDs that are currently being indexed
-	const indexingConnectorIds = useMemo(() => {
-		if (!logsSummary?.active_tasks) return new Set<number>();
-		return new Set(
-			logsSummary.active_tasks
-				.filter((task) => task.source?.includes("connector_indexing") && task.connector_id != null)
-				.map((task) => task.connector_id as number)
-		);
-	}, [logsSummary?.active_tasks]);
+	// Track indexing state locally - clears automatically when Electric SQL detects last_indexed_at changed
+	const { indexingConnectorIds, startIndexing } = useIndexingConnectors(
+		connectors as SearchSourceConnector[]
+	);
 
 	const isLoading = connectorsLoading || documentTypesLoading;
 
@@ -155,11 +130,13 @@ export const ConnectorIndicator: FC = () => {
 	const hasConnectors = connectors.length > 0;
 	const hasSources = hasConnectors || activeDocumentTypes.length > 0;
 	const totalSourceCount = connectors.length + activeDocumentTypes.length;
-	const activeConnectorsCount = connectors.length; // Only actual connectors, not document types
+	
+	const activeConnectorsCount = connectors.length;
 
 	// Check which connectors are already connected
+	// Using Electric SQL + PGlite for real-time connector updates
 	const connectedTypes = new Set(
-		(allConnectors || []).map((c: SearchSourceConnector) => c.connector_type)
+		(connectors || []).map((c: SearchSourceConnector) => c.connector_type)
 	);
 
 	if (!searchSpaceId) return null;
@@ -199,13 +176,25 @@ export const ConnectorIndicator: FC = () => {
 				{/* YouTube Crawler View - shown when adding YouTube videos */}
 				{isYouTubeView && searchSpaceId ? (
 					<YouTubeCrawlerView searchSpaceId={searchSpaceId} onBack={handleBackFromYouTube} />
+				) : viewingMCPList ? (
+					<div className="p-6 sm:p-12 h-full overflow-hidden">
+						<MCPConnectorListView
+							mcpConnectors={
+								(allConnectors || []).filter(
+									(c: SearchSourceConnector) => c.connector_type === "MCP_CONNECTOR"
+								) as SearchSourceConnector[]
+							}
+							onAddNew={handleAddNewMCPFromList}
+							onManageConnector={handleStartEdit}
+							onBack={handleBackFromMCPList}
+						/>
+					</div>
 				) : viewingAccountsType ? (
 					<ConnectorAccountsListView
 						connectorType={viewingAccountsType.connectorType}
 						connectorTitle={viewingAccountsType.connectorTitle}
-						connectors={(allConnectors || []) as SearchSourceConnector[]}
+						connectors={(connectors || []) as SearchSourceConnector[]} // Using Electric SQL + PGlite for real-time connector updates (all connector types)
 						indexingConnectorIds={indexingConnectorIds}
-						logsSummary={logsSummary}
 						onBack={handleBackFromAccountsList}
 						onManage={handleStartEdit}
 						onAddAccount={() => {
@@ -221,7 +210,7 @@ export const ConnectorIndicator: FC = () => {
 				) : connectingConnectorType ? (
 					<ConnectorConnectView
 						connectorType={connectingConnectorType}
-						onSubmit={handleSubmitConnectForm}
+						onSubmit={(formData) => handleSubmitConnectForm(formData, startIndexing)}
 						onBack={handleBackFromConnect}
 						isSubmitting={isCreatingConnector}
 					/>
@@ -239,17 +228,24 @@ export const ConnectorIndicator: FC = () => {
 						isSaving={isSaving}
 						isDisconnecting={isDisconnecting}
 						isIndexing={indexingConnectorIds.has(editingConnector.id)}
+						searchSpaceId={searchSpaceId?.toString()}
+
 						onStartDateChange={setStartDate}
 						onEndDateChange={setEndDate}
 						onPeriodicEnabledChange={setPeriodicEnabled}
 						onFrequencyChange={setFrequencyMinutes}
-						onSave={() => handleSaveConnector(() => refreshConnectors())}
+						onSave={() => {
+							startIndexing(editingConnector.id);
+							handleSaveConnector(() => refreshConnectors());
+						}}
 						onDisconnect={() => handleDisconnectConnector(() => refreshConnectors())}
 						onBack={handleBackFromEdit}
 						onQuickIndex={
 							editingConnector.connector_type !== "GOOGLE_DRIVE_CONNECTOR"
-								? () =>
-										handleQuickIndexConnector(editingConnector.id, editingConnector.connector_type)
+								? () => {
+										startIndexing(editingConnector.id);
+										handleQuickIndexConnector(editingConnector.id, editingConnector.connector_type);
+									}
 								: undefined
 						}
 						onConfigChange={setConnectorConfig}
@@ -276,7 +272,12 @@ export const ConnectorIndicator: FC = () => {
 						onPeriodicEnabledChange={setPeriodicEnabled}
 						onFrequencyChange={setFrequencyMinutes}
 						onConfigChange={setIndexingConnectorConfig}
-						onStartIndexing={() => handleStartIndexing(() => refreshConnectors())}
+						onStartIndexing={() => {
+							if (indexingConfig.connectorId) {
+								startIndexing(indexingConfig.connectorId);
+							}
+							handleStartIndexing(() => refreshConnectors());
+						}}
 						onSkip={handleSkipIndexing}
 					/>
 				) : (
@@ -305,10 +306,9 @@ export const ConnectorIndicator: FC = () => {
 											searchSpaceId={searchSpaceId}
 											connectedTypes={connectedTypes}
 											connectingId={connectingId}
-											allConnectors={allConnectors}
+											allConnectors={connectors}
 											documentTypeCounts={documentTypeCounts}
 											indexingConnectorIds={indexingConnectorIds}
-											logsSummary={logsSummary}
 											onConnectOAuth={handleConnectOAuth}
 											onConnectNonOAuth={handleConnectNonOAuth}
 											onCreateWebcrawler={handleCreateWebcrawler}
@@ -325,7 +325,6 @@ export const ConnectorIndicator: FC = () => {
 										activeDocumentTypes={activeDocumentTypes}
 										connectors={connectors as SearchSourceConnector[]}
 										indexingConnectorIds={indexingConnectorIds}
-										logsSummary={logsSummary}
 										searchSpaceId={searchSpaceId}
 										onTabChange={handleTabChange}
 										onManage={handleStartEdit}

surfsense_web/components/assistant-ui/connector-popup/components/connector-card.tsx

@@ -1,12 +1,10 @@
 "use client";
 
 import { IconBrandYoutube } from "@tabler/icons-react";
-import { differenceInDays, differenceInMinutes, format, isToday, isYesterday } from "date-fns";
 import { FileText, Loader2 } from "lucide-react";
 import type { FC } from "react";
 import { Button } from "@/components/ui/button";
 import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
-import type { LogActiveTask } from "@/contracts/types/log.types";
 import { cn } from "@/lib/utils";
 import { useConnectorStatus } from "../hooks/use-connector-status";
 import { ConnectorStatusBadge } from "./connector-status-badge";
@@ -20,24 +18,11 @@ interface ConnectorCardProps {
 	isConnecting?: boolean;
 	documentCount?: number;
 	accountCount?: number;
-	lastIndexedAt?: string | null;
 	isIndexing?: boolean;
-	activeTask?: LogActiveTask;
 	onConnect?: () => void;
 	onManage?: () => void;
 }
 
-/**
- * Extract a number from the active task message for display
- * Looks for patterns like "45 indexed", "Processing 123", etc.
- */
-function extractIndexedCount(message: string | undefined): number | null {
-	if (!message) return null;
-	// Try to find a number in the message
-	const match = message.match(/(\d+)/);
-	return match ? parseInt(match[1], 10) : null;
-}
-
 /**
  * Format document count (e.g., "1.2k docs", "500 docs", "1.5M docs")
  */
@@ -52,45 +37,6 @@ function formatDocumentCount(count: number | undefined): string {
 	return `${m.replace(/\.0$/, "")}M docs`;
 }
 
-/**
- * Format last indexed date with contextual messages
- * Examples: "Just now", "10 minutes ago", "Today at 2:30 PM", "Yesterday at 3:45 PM", "3 days ago", "Jan 15, 2026"
- */
-function formatLastIndexedDate(dateString: string): string {
-	const date = new Date(dateString);
-	const now = new Date();
-	const minutesAgo = differenceInMinutes(now, date);
-	const daysAgo = differenceInDays(now, date);
-
-	// Just now (within last minute)
-	if (minutesAgo < 1) {
-		return "Just now";
-	}
-
-	// X minutes ago (less than 1 hour)
-	if (minutesAgo < 60) {
-		return `${minutesAgo} ${minutesAgo === 1 ? "minute" : "minutes"} ago`;
-	}
-
-	// Today at [time]
-	if (isToday(date)) {
-		return `Today at ${format(date, "h:mm a")}`;
-	}
-
-	// Yesterday at [time]
-	if (isYesterday(date)) {
-		return `Yesterday at ${format(date, "h:mm a")}`;
-	}
-
-	// X days ago (less than 7 days)
-	if (daysAgo < 7) {
-		return `${daysAgo} ${daysAgo === 1 ? "day" : "days"} ago`;
-	}
-
-	// Full date for older entries
-	return format(date, "MMM d, yyyy");
-}
-
 export const ConnectorCard: FC<ConnectorCardProps> = ({
 	id,
 	title,
@@ -100,9 +46,7 @@ export const ConnectorCard: FC<ConnectorCardProps> = ({
 	isConnecting = false,
 	documentCount,
 	accountCount,
-	lastIndexedAt,
 	isIndexing = false,
-	activeTask,
 	onConnect,
 	onManage,
 }) => {
@@ -115,36 +59,11 @@ export const ConnectorCard: FC<ConnectorCardProps> = ({
 	const statusMessage = getConnectorStatusMessage(connectorType);
 	const showWarnings = shouldShowWarnings();
 
-	// Extract count from active task message during indexing
-	const indexingCount = extractIndexedCount(activeTask?.message);
-
 	// Determine the status content to display
 	const getStatusContent = () => {
-		if (isIndexing) {
-			return (
-				<div className="flex items-center gap-2 w-full max-w-[200px]">
-					<span className="text-[11px] text-primary font-medium whitespace-nowrap">
-						{indexingCount !== null ? <>{indexingCount.toLocaleString()} indexed</> : "Syncing..."}
-					</span>
-					{/* Indeterminate progress bar with animation */}
-					<div className="relative flex-1 h-1 overflow-hidden rounded-full bg-primary/20">
-						<div className="absolute h-full bg-primary rounded-full animate-progress-indeterminate" />
-					</div>
-				</div>
-			);
-		}
-
 		if (isConnected) {
-			// Show last indexed date for connected connectors
-			if (lastIndexedAt) {
-				return (
-					<span className="whitespace-nowrap text-[10px]">
-						Last indexed: {formatLastIndexedDate(lastIndexedAt)}
-					</span>
-				);
-			}
-			// Fallback for connected but never indexed
-			return <span className="whitespace-nowrap text-[10px]">Never indexed</span>;
+			// Don't show last indexed in overview tabs - only show in accounts list view
+			return null;
 		}
 
 		return description;
@@ -186,9 +105,13 @@ export const ConnectorCard: FC<ConnectorCardProps> = ({
 						/>
 					)}
 				</div>
-				<div className="text-[10px] text-muted-foreground mt-1">{getStatusContent()}</div>
-				{isConnected && documentCount !== undefined && (
-					<p className="text-[10px] text-muted-foreground mt-0.5 flex items-center gap-1.5">
+				{isIndexing ? (
+					<p className="text-[11px] text-primary mt-1 flex items-center gap-1.5">
+						<Loader2 className="size-3 animate-spin" />
+						Syncing
+					</p>
+				) : isConnected ? (
+					<p className="text-[10px] text-muted-foreground mt-1 flex items-center gap-1.5">
 						<span>{formatDocumentCount(documentCount)}</span>
 						{accountCount !== undefined && accountCount > 0 && (
 							<>
@@ -199,6 +122,8 @@ export const ConnectorCard: FC<ConnectorCardProps> = ({
 							</>
 						)}
 					</p>
+				) : (
+					<div className="text-[10px] text-muted-foreground mt-1">{getStatusContent()}</div>
 				)}
 			</div>
 			<Button

surfsense_web/components/assistant-ui/connector-popup/components/connector-status-badge.tsx

@@ -44,7 +44,7 @@ export const ConnectorStatusBadge: FC<ConnectorStatusBadgeProps> = ({
 			case "deprecated":
 				return {
 					icon: AlertTriangle,
-					className: "ext-slate-500 dark:text-slate-400",
+					className: "text-slate-500 dark:text-slate-400",
 					defaultTitle: "Deprecated",
 				};
 			default:

surfsense_web/components/assistant-ui/connector-popup/components/periodic-sync-config.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import type { FC } from "react";
+import { AlertCircle } from "lucide-react";
 import { Label } from "@/components/ui/label";
 import {
 	Select,
@@ -16,6 +17,8 @@ interface PeriodicSyncConfigProps {
 	frequencyMinutes: string;
 	onEnabledChange: (enabled: boolean) => void;
 	onFrequencyChange: (frequency: string) => void;
+	disabled?: boolean;
+	disabledMessage?: string;
 }
 
 export const PeriodicSyncConfig: FC<PeriodicSyncConfigProps> = ({
@@ -23,6 +26,8 @@ export const PeriodicSyncConfig: FC<PeriodicSyncConfigProps> = ({
 	frequencyMinutes,
 	onEnabledChange,
 	onFrequencyChange,
+	disabled = false,
+	disabledMessage,
 }) => {
 	return (
 		<div className="rounded-xl bg-slate-400/5 dark:bg-white/5 p-3 sm:p-6">
@@ -33,9 +38,17 @@ export const PeriodicSyncConfig: FC<PeriodicSyncConfigProps> = ({
 						Automatically re-index at regular intervals
 					</p>
 				</div>
-				<Switch checked={enabled} onCheckedChange={onEnabledChange} />
+				<Switch checked={enabled} onCheckedChange={onEnabledChange} disabled={disabled} />
 			</div>
 
+			{/* Show disabled message when periodic sync can't be enabled */}
+			{disabled && disabledMessage && (
+				<div className="mt-3 flex items-start gap-2 text-amber-600 dark:text-amber-400">
+					<AlertCircle className="size-4 mt-0.5 shrink-0" />
+					<p className="text-xs sm:text-sm">{disabledMessage}</p>
+				</div>
+			)}
+
 			{enabled && (
 				<div className="mt-4 pt-4 border-t border-slate-400/20 space-y-3">
 					<div className="space-y-2">

surfsense_web/components/assistant-ui/connector-popup/connect-forms/components/mcp-connect-form.tsx

@@ -0,0 +1,229 @@
+"use client";
+
+import { CheckCircle2, ChevronDown, ChevronUp, Server, XCircle } from "lucide-react";
+import { type FC, useRef, useState } from "react";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Textarea } from "@/components/ui/textarea";
+import { EnumConnectorName } from "@/contracts/enums/connector";
+import type { MCPToolDefinition } from "@/contracts/types/mcp.types";
+import type { ConnectFormProps } from "..";
+import {
+	extractServerName,
+	parseMCPConfig,
+	testMCPConnection,
+	type MCPConnectionTestResult,
+} from "../../utils/mcp-config-validator";
+
+export const MCPConnectForm: FC<ConnectFormProps> = ({ onSubmit, isSubmitting }) => {
+	const isSubmittingRef = useRef(false);
+	const [configJson, setConfigJson] = useState("");
+	const [jsonError, setJsonError] = useState<string | null>(null);
+	const [isTesting, setIsTesting] = useState(false);
+	const [showDetails, setShowDetails] = useState(false);
+	const [testResult, setTestResult] = useState<MCPConnectionTestResult | null>(null);
+
+	const DEFAULT_CONFIG = JSON.stringify(
+		{
+			name: "My MCP Server",
+			command: "npx",
+			args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"],
+			env: {
+				API_KEY: "your_api_key_here",
+			},
+			transport: "stdio",
+		},
+		null,
+		2
+	);
+
+	const parseConfig = () => {
+		const result = parseMCPConfig(configJson);
+		if (result.error) {
+			setJsonError(result.error);
+		} else {
+			setJsonError(null);
+		}
+		return result.config;
+	};
+
+	const handleConfigChange = (value: string) => {
+		setConfigJson(value);
+		
+		// Clear previous error
+		if (jsonError) {
+			setJsonError(null);
+		}
+		
+		// Validate immediately to show errors as user types (with debouncing via parseMCPConfig cache)
+		if (value.trim()) {
+			const result = parseMCPConfig(value);
+			if (result.error) {
+				setJsonError(result.error);
+			}
+		}
+	};
+
+	const handleTestConnection = async () => {
+		const serverConfig = parseConfig();
+		if (!serverConfig) {
+			setTestResult({
+				status: "error",
+				message: jsonError || "Invalid configuration",
+				tools: [],
+			});
+			return;
+		}
+
+		setIsTesting(true);
+		setTestResult(null);
+
+		const result = await testMCPConnection(serverConfig);
+		setTestResult(result);
+		setIsTesting(false);
+	};
+
+	const handleSubmit = async (e: React.FormEvent) => {
+		e.preventDefault();
+
+		// Prevent multiple submissions
+		if (isSubmittingRef.current || isSubmitting) {
+			return;
+		}
+
+		const serverConfig = parseConfig();
+		if (!serverConfig) {
+			return;
+		}
+
+		// Extract server name from config if provided
+		const serverName = extractServerName(configJson);
+
+		isSubmittingRef.current = true;
+		try {
+			await onSubmit({
+				name: serverName,
+				connector_type: EnumConnectorName.MCP_CONNECTOR,
+				config: { server_config: serverConfig },
+				is_indexable: false,
+				is_active: true,
+				last_indexed_at: null,
+				periodic_indexing_enabled: false,
+				indexing_frequency_minutes: null,
+				next_scheduled_at: null,
+			});
+		} finally {
+			isSubmittingRef.current = false;
+		}
+	};
+
+	return (
+		<div className="space-y-6 pb-6">
+			<Alert className="bg-slate-400/5 dark:bg-white/5 border-slate-400/20 p-2 sm:p-3 [&>svg]:top-2 sm:[&>svg]:top-3">
+			<Server className="h-4 w-4 shrink-0" />
+			<AlertDescription className="text-[10px] sm:text-xs">
+				Connect to an MCP (Model Context Protocol) server. Each MCP server is added as a separate connector.
+			</AlertDescription>
+		</Alert>
+
+			<form id="mcp-connect-form" onSubmit={handleSubmit} className="space-y-6">
+				<div className="rounded-xl border border-border bg-slate-400/5 dark:bg-white/5 p-4 sm:p-6 space-y-4">
+					<div className="space-y-2">
+						<Label htmlFor="config">MCP Server Configuration (JSON)</Label>
+						<Textarea
+							id="config"
+							value={configJson}
+							onChange={(e) => handleConfigChange(e.target.value)}
+							placeholder={DEFAULT_CONFIG}
+							rows={16}
+							className={`font-mono text-xs ${jsonError ? "border-red-500" : ""}`}
+						/>
+						{jsonError && (
+							<p className="text-xs text-red-500">JSON Error: {jsonError}</p>
+						)}
+						<p className="text-[10px] sm:text-xs text-muted-foreground">
+							Paste a single MCP server configuration. Must include: name, command, args (optional), env (optional), transport (optional).
+						</p>
+					</div>
+
+					<div className="pt-4">
+						<Button
+							type="button"
+							onClick={handleTestConnection}
+							disabled={isTesting}
+							variant="outline"
+							className="w-full"
+						>
+							{isTesting ? "Testing Connection..." : "Test Connection"}
+						</Button>
+					</div>
+
+					{testResult && (
+						<Alert
+							className={
+								testResult.status === "success"
+									? "border-green-500/50 bg-green-500/10"
+									: "border-red-500/50 bg-red-500/10"
+							}
+						>
+							{testResult.status === "success" ? (
+								<CheckCircle2 className="h-4 w-4 text-green-600" />
+							) : (
+								<XCircle className="h-4 w-4 text-red-600" />
+							)}
+							<div className="flex-1">
+								<div className="flex items-center justify-between">
+									<AlertTitle className="text-sm">
+										{testResult.status === "success" ? "Connection Successful" : "Connection Failed"}
+									</AlertTitle>
+									{testResult.tools.length > 0 && (
+										<Button
+											type="button"
+											variant="ghost"
+											size="sm"
+											className="h-6 px-2"
+											onClick={(e) => {
+												e.preventDefault();
+												e.stopPropagation();
+												setShowDetails(!showDetails);
+											}}
+										>
+											{showDetails ? (
+												<>
+													<ChevronUp className="h-3 w-3 mr-1" />
+													Hide Details
+												</>
+											) : (
+												<>
+													<ChevronDown className="h-3 w-3 mr-1" />
+													Show Details
+												</>
+											)}
+										</Button>
+									)}
+								</div>
+								<AlertDescription className="text-xs mt-1">
+									{testResult.message}
+									{showDetails && testResult.tools.length > 0 && (
+										<div className="mt-3 pt-3 border-t border-green-500/20">
+											<p className="font-semibold mb-2">
+												Available tools:
+											</p>
+											<ul className="list-disc list-inside text-xs space-y-0.5">
+												{testResult.tools.map((tool, i) => (
+													<li key={i}>{tool.name}</li>
+												))}
+											</ul>
+										</div>
+									)}
+								</AlertDescription>
+							</div>
+						</Alert>
+					)}
+				</div>
+			</form>
+		</div>
+	);
+};

surfsense_web/components/assistant-ui/connector-popup/connect-forms/index.tsx

@@ -6,6 +6,7 @@ import { ElasticsearchConnectForm } from "./components/elasticsearch-connect-for
 import { GithubConnectForm } from "./components/github-connect-form";
 import { LinkupApiConnectForm } from "./components/linkup-api-connect-form";
 import { LumaConnectForm } from "./components/luma-connect-form";
+import { MCPConnectForm } from "./components/mcp-connect-form";
 import { SearxngConnectForm } from "./components/searxng-connect-form";
 import { TavilyApiConnectForm } from "./components/tavily-api-connect-form";
 
@@ -15,6 +16,7 @@ export interface ConnectFormProps {
 		connector_type: string;
 		config: Record<string, unknown>;
 		is_indexable: boolean;
+		is_active: boolean;
 		last_indexed_at: null;
 		periodic_indexing_enabled: boolean;
 		indexing_frequency_minutes: number | null;
@@ -54,6 +56,8 @@ export function getConnectFormComponent(connectorType: string): ConnectFormCompo
 			return LumaConnectForm;
 		case "CIRCLEBACK_CONNECTOR":
 			return CirclebackConnectForm;
+		case "MCP_CONNECTOR":
+			return MCPConnectForm;
 		// Add other connector types here as needed
 		default:
 			return null;

surfsense_web/components/assistant-ui/connector-popup/connector-configs/components/google-drive-config.tsx

@@ -1,11 +1,19 @@
 "use client";
 
-import { Info } from "lucide-react";
+import { File, FileText, FileSpreadsheet, FolderClosed, Image, Presentation } from "lucide-react";
 import type { FC } from "react";
 import { useEffect, useState } from "react";
 import { GoogleDriveFolderTree } from "@/components/connectors/google-drive-folder-tree";
-import { Alert, AlertDescription } from "@/components/ui/alert";
 import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
 import type { ConnectorConfigProps } from "../index";
 
 interface SelectedFolder {
@@ -13,128 +21,292 @@ interface SelectedFolder {
 	name: string;
 }
 
+interface IndexingOptions {
+	max_files_per_folder: number;
+	incremental_sync: boolean;
+	include_subfolders: boolean;
+}
+
+const DEFAULT_INDEXING_OPTIONS: IndexingOptions = {
+	max_files_per_folder: 100,
+	incremental_sync: true,
+	include_subfolders: true,
+};
+
+// Helper to get appropriate icon for file type based on file name
+function getFileIconFromName(fileName: string, className: string = "size-3.5 shrink-0") {
+	const lowerName = fileName.toLowerCase();
+	// Spreadsheets
+	if (
+		lowerName.endsWith(".xlsx") ||
+		lowerName.endsWith(".xls") ||
+		lowerName.endsWith(".csv") ||
+		lowerName.includes("spreadsheet")
+	) {
+		return <FileSpreadsheet className={`${className} text-green-500`} />;
+	}
+	// Presentations
+	if (
+		lowerName.endsWith(".pptx") ||
+		lowerName.endsWith(".ppt") ||
+		lowerName.includes("presentation")
+	) {
+		return <Presentation className={`${className} text-orange-500`} />;
+	}
+	// Documents (word, text only - not PDF)
+	if (
+		lowerName.endsWith(".docx") ||
+		lowerName.endsWith(".doc") ||
+		lowerName.endsWith(".txt") ||
+		lowerName.includes("document") ||
+		lowerName.includes("word") ||
+		lowerName.includes("text")
+	) {
+		return <FileText className={`${className} text-gray-500`} />;
+	}
+	// Images
+	if (
+		lowerName.endsWith(".png") ||
+		lowerName.endsWith(".jpg") ||
+		lowerName.endsWith(".jpeg") ||
+		lowerName.endsWith(".gif") ||
+		lowerName.endsWith(".webp") ||
+		lowerName.endsWith(".svg")
+	) {
+		return <Image className={`${className} text-purple-500`} />;
+	}
+	// Default (including PDF)
+	return <File className={`${className} text-gray-500`} />;
+}
+
 export const GoogleDriveConfig: FC<ConnectorConfigProps> = ({ connector, onConfigChange }) => {
 	// Initialize with existing selected folders and files from connector config
 	const existingFolders =
 		(connector.config?.selected_folders as SelectedFolder[] | undefined) || [];
 	const existingFiles = (connector.config?.selected_files as SelectedFolder[] | undefined) || [];
+	const existingIndexingOptions =
+		(connector.config?.indexing_options as IndexingOptions | undefined) || DEFAULT_INDEXING_OPTIONS;
+
 	const [selectedFolders, setSelectedFolders] = useState<SelectedFolder[]>(existingFolders);
 	const [selectedFiles, setSelectedFiles] = useState<SelectedFolder[]>(existingFiles);
 	const [showFolderSelector, setShowFolderSelector] = useState(false);
+	const [indexingOptions, setIndexingOptions] = useState<IndexingOptions>(existingIndexingOptions);
 
 	// Update selected folders and files when connector config changes
 	useEffect(() => {
 		const folders = (connector.config?.selected_folders as SelectedFolder[] | undefined) || [];
 		const files = (connector.config?.selected_files as SelectedFolder[] | undefined) || [];
+		const options =
+			(connector.config?.indexing_options as IndexingOptions | undefined) ||
+			DEFAULT_INDEXING_OPTIONS;
 		setSelectedFolders(folders);
 		setSelectedFiles(files);
+		setIndexingOptions(options);
 	}, [connector.config]);
 
-	const handleSelectFolders = (folders: SelectedFolder[]) => {
-		setSelectedFolders(folders);
+	const updateConfig = (
+		folders: SelectedFolder[],
+		files: SelectedFolder[],
+		options: IndexingOptions
+	) => {
 		if (onConfigChange) {
-			// Store folder IDs and names in config for indexing
 			onConfigChange({
 				...connector.config,
 				selected_folders: folders,
-				selected_files: selectedFiles, // Preserve existing files
+				selected_files: files,
+				indexing_options: options,
 			});
 		}
 	};
 
+	const handleSelectFolders = (folders: SelectedFolder[]) => {
+		setSelectedFolders(folders);
+		updateConfig(folders, selectedFiles, indexingOptions);
+	};
+
 	const handleSelectFiles = (files: SelectedFolder[]) => {
 		setSelectedFiles(files);
-		if (onConfigChange) {
-			// Store file IDs and names in config for indexing
-			onConfigChange({
-				...connector.config,
-				selected_folders: selectedFolders, // Preserve existing folders
-				selected_files: files,
-			});
-		}
+		updateConfig(selectedFolders, files, indexingOptions);
+	};
+
+	const handleIndexingOptionChange = (key: keyof IndexingOptions, value: number | boolean) => {
+		const newOptions = { ...indexingOptions, [key]: value };
+		setIndexingOptions(newOptions);
+		updateConfig(selectedFolders, selectedFiles, newOptions);
 	};
 
 	const totalSelected = selectedFolders.length + selectedFiles.length;
 
 	return (
-		<div className="rounded-xl border border-border bg-slate-400/5 dark:bg-white/5 p-3 sm:p-6 space-y-3 sm:space-y-4">
-			<div className="space-y-1 sm:space-y-2">
-				<h3 className="font-medium text-sm sm:text-base">Folder & File Selection</h3>
-				<p className="text-xs sm:text-sm text-muted-foreground">
-					Select specific folders and/or individual files to index. Only files directly in each
-					folder will be processed—subfolders must be selected separately.
-				</p>
-			</div>
-
-			{totalSelected > 0 && (
-				<div className="p-2 sm:p-3 bg-muted rounded-lg text-xs sm:text-sm space-y-1 sm:space-y-2">
-					<p className="font-medium">
-						Selected {totalSelected} item{totalSelected > 1 ? "s" : ""}:
-						{selectedFolders.length > 0 &&
-							` ${selectedFolders.length} folder${selectedFolders.length > 1 ? "s" : ""}`}
-						{selectedFiles.length > 0 &&
-							` ${selectedFiles.length} file${selectedFiles.length > 1 ? "s" : ""}`}
+		<div className="space-y-4">
+			{/* Folder & File Selection */}
+			<div className="rounded-xl border border-border bg-slate-400/5 dark:bg-white/5 p-3 sm:p-6 space-y-3 sm:space-y-4">
+				<div className="space-y-1 sm:space-y-2">
+					<h3 className="font-medium text-sm sm:text-base">Folder & File Selection</h3>
+					<p className="text-xs sm:text-sm text-muted-foreground">
+						Select specific folders and/or individual files to index.
 					</p>
-					<div className="max-h-20 sm:max-h-24 overflow-y-auto space-y-1">
-						{selectedFolders.map((folder) => (
-							<p
-								key={folder.id}
-								className="text-xs sm:text-sm text-muted-foreground truncate"
-								title={folder.name}
-							>
-								📁 {folder.name}
-							</p>
-						))}
-						{selectedFiles.map((file) => (
-							<p
-								key={file.id}
-								className="text-xs sm:text-sm text-muted-foreground truncate"
-								title={file.name}
-							>
-								📄 {file.name}
-							</p>
-						))}
-					</div>
 				</div>
-			)}
 
-			{showFolderSelector ? (
-				<div className="space-y-2 sm:space-y-3">
-					<GoogleDriveFolderTree
-						connectorId={connector.id}
-						selectedFolders={selectedFolders}
-						onSelectFolders={handleSelectFolders}
-						selectedFiles={selectedFiles}
-						onSelectFiles={handleSelectFiles}
-					/>
+				{totalSelected > 0 && (
+					<div className="p-2 sm:p-3 bg-muted rounded-lg text-xs sm:text-sm space-y-1 sm:space-y-2">
+						<p className="font-medium">
+							Selected {totalSelected} item{totalSelected > 1 ? "s" : ""}: {(() => {
+								const parts: string[] = [];
+								if (selectedFolders.length > 0) {
+									parts.push(
+										`${selectedFolders.length} folder${selectedFolders.length > 1 ? "s" : ""}`
+									);
+								}
+								if (selectedFiles.length > 0) {
+									parts.push(`${selectedFiles.length} file${selectedFiles.length > 1 ? "s" : ""}`);
+								}
+								return parts.length > 0 ? `(${parts.join(" ")})` : "";
+							})()}
+						</p>
+						<div className="max-h-20 sm:max-h-24 overflow-y-auto space-y-1">
+							{selectedFolders.map((folder) => (
+								<p
+									key={folder.id}
+									className="text-xs sm:text-sm text-muted-foreground truncate flex items-center gap-1.5"
+									title={folder.name}
+								>
+									<FolderClosed className="size-3.5 shrink-0 text-gray-500" />
+									{folder.name}
+								</p>
+							))}
+							{selectedFiles.map((file) => (
+								<p
+									key={file.id}
+									className="text-xs sm:text-sm text-muted-foreground truncate flex items-center gap-1.5"
+									title={file.name}
+								>
+									{getFileIconFromName(file.name)}
+									{file.name}
+								</p>
+							))}
+						</div>
+					</div>
+				)}
+
+				{showFolderSelector ? (
+					<div className="space-y-2 sm:space-y-3">
+						<GoogleDriveFolderTree
+							connectorId={connector.id}
+							selectedFolders={selectedFolders}
+							onSelectFolders={handleSelectFolders}
+							selectedFiles={selectedFiles}
+							onSelectFiles={handleSelectFiles}
+						/>
+						<Button
+							type="button"
+							variant="outline"
+							size="sm"
+							onClick={() => setShowFolderSelector(false)}
+							className="bg-slate-400/5 dark:bg-white/5 border-slate-400/20 hover:bg-slate-400/10 dark:hover:bg-white/10 text-xs sm:text-sm h-8 sm:h-9"
+						>
+							Done Selecting
+						</Button>
+					</div>
+				) : (
 					<Button
 						type="button"
 						variant="outline"
-						size="sm"
-						onClick={() => setShowFolderSelector(false)}
+						onClick={() => setShowFolderSelector(true)}
 						className="bg-slate-400/5 dark:bg-white/5 border-slate-400/20 hover:bg-slate-400/10 dark:hover:bg-white/10 text-xs sm:text-sm h-8 sm:h-9"
 					>
-						Done Selecting
+						{totalSelected > 0 ? "Change Selection" : "Select Folders & Files"}
 					</Button>
-				</div>
-			) : (
-				<Button
-					type="button"
-					variant="outline"
-					onClick={() => setShowFolderSelector(true)}
-					className="bg-slate-400/5 dark:bg-white/5 border-slate-400/20 hover:bg-slate-400/10 dark:hover:bg-white/10 text-xs sm:text-sm h-8 sm:h-9"
-				>
-					{totalSelected > 0 ? "Change Selection" : "Select Folders & Files"}
-				</Button>
-			)}
+				)}
+			</div>
 
-			<Alert className="bg-slate-400/5 dark:bg-white/5 border-slate-400/20 p-2 sm:p-3 flex items-center gap-2 [&>svg]:relative [&>svg]:left-0 [&>svg]:top-0 [&>svg+div]:translate-y-0">
-				<Info className="h-3 w-3 sm:h-4 sm:w-4 shrink-0" />
-				<AlertDescription className="text-[10px] sm:text-xs !pl-0">
-					Folder and file selection is used when indexing. You can change this selection when you
-					start indexing.
-				</AlertDescription>
-			</Alert>
+			{/* Indexing Options */}
+			<div className="rounded-xl border border-border bg-slate-400/5 dark:bg-white/5 p-3 sm:p-6 space-y-4">
+				<div className="space-y-1 sm:space-y-2">
+					<h3 className="font-medium text-sm sm:text-base">Indexing Options</h3>
+					<p className="text-xs sm:text-sm text-muted-foreground">
+						Configure how files are indexed from your Google Drive.
+					</p>
+				</div>
+
+				{/* Max files per folder */}
+				<div className="space-y-2">
+					<div className="flex items-center justify-between">
+						<div className="space-y-0.5">
+							<Label htmlFor="max-files" className="text-sm font-medium">
+								Max files per folder
+							</Label>
+							<p className="text-xs text-muted-foreground">
+								Maximum number of files to index from each folder
+							</p>
+						</div>
+						<Select
+							value={indexingOptions.max_files_per_folder.toString()}
+							onValueChange={(value) =>
+								handleIndexingOptionChange("max_files_per_folder", parseInt(value, 10))
+							}
+						>
+							<SelectTrigger
+								id="max-files"
+								className="w-[140px] bg-slate-400/5 dark:bg-slate-400/5 border-slate-400/20 text-xs sm:text-sm"
+							>
+								<SelectValue placeholder="Select limit" />
+							</SelectTrigger>
+							<SelectContent className="z-[100]">
+								<SelectItem value="50" className="text-xs sm:text-sm">
+									50 files
+								</SelectItem>
+								<SelectItem value="100" className="text-xs sm:text-sm">
+									100 files
+								</SelectItem>
+								<SelectItem value="250" className="text-xs sm:text-sm">
+									250 files
+								</SelectItem>
+								<SelectItem value="500" className="text-xs sm:text-sm">
+									500 files
+								</SelectItem>
+								<SelectItem value="1000" className="text-xs sm:text-sm">
+									1000 files
+								</SelectItem>
+							</SelectContent>
+						</Select>
+					</div>
+				</div>
+
+				{/* Incremental sync toggle */}
+				<div className="flex items-center justify-between pt-2 border-t border-slate-400/20">
+					<div className="space-y-0.5">
+						<Label htmlFor="incremental-sync" className="text-sm font-medium">
+							Incremental sync
+						</Label>
+						<p className="text-xs text-muted-foreground">
+							Only sync changes since last index (faster). Disable for a full re-index.
+						</p>
+					</div>
+					<Switch
+						id="incremental-sync"
+						checked={indexingOptions.incremental_sync}
+						onCheckedChange={(checked) => handleIndexingOptionChange("incremental_sync", checked)}
+					/>
+				</div>
+
+				{/* Include subfolders toggle */}
+				<div className="flex items-center justify-between pt-2 border-t border-slate-400/20">
+					<div className="space-y-0.5">
+						<Label htmlFor="include-subfolders" className="text-sm font-medium">
+							Include subfolders
+						</Label>
+						<p className="text-xs text-muted-foreground">
+							Recursively index files in subfolders of selected folders
+						</p>
+					</div>
+					<Switch
+						id="include-subfolders"
+						checked={indexingOptions.include_subfolders}
+						onCheckedChange={(checked) => handleIndexingOptionChange("include_subfolders", checked)}
+					/>
+				</div>
+			</div>
 		</div>
 	);
 };

surfsense_web/components/assistant-ui/connector-popup/connector-configs/components/mcp-config.tsx

@@ -0,0 +1,245 @@
+"use client";
+
+import { CheckCircle2, ChevronDown, ChevronUp, Server, XCircle } from "lucide-react";
+import type { FC } from "react";
+import { useEffect, useState } from "react";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Textarea } from "@/components/ui/textarea";
+import { EnumConnectorName } from "@/contracts/enums/connector";
+import type { MCPServerConfig, MCPToolDefinition } from "@/contracts/types/mcp.types";
+import type { ConnectorConfigProps } from "../index";
+import {
+	parseMCPConfig,
+	testMCPConnection,
+	type MCPConnectionTestResult,
+} from "../../utils/mcp-config-validator";
+
+interface MCPConfigProps extends ConnectorConfigProps {
+	onNameChange?: (name: string) => void;
+}
+
+export const MCPConfig: FC<MCPConfigProps> = ({ connector, onConfigChange, onNameChange }) => {
+	// Validate that this is an MCP connector
+	if (connector.connector_type !== EnumConnectorName.MCP_CONNECTOR) {
+		console.error(
+			"MCPConfig received non-MCP connector:",
+			connector.connector_type
+		);
+		return (
+			<Alert className="border-red-500/50 bg-red-500/10">
+				<XCircle className="h-4 w-4 text-red-600" />
+				<AlertTitle>Invalid Connector Type</AlertTitle>
+				<AlertDescription>
+					This component can only be used with MCP connectors.
+				</AlertDescription>
+			</Alert>
+		);
+	}
+
+	const [name, setName] = useState<string>("");
+	const [configJson, setConfigJson] = useState("");
+	const [jsonError, setJsonError] = useState<string | null>(null);
+	const [isTesting, setIsTesting] = useState(false);
+	const [showDetails, setShowDetails] = useState(false);
+	const [testResult, setTestResult] = useState<MCPConnectionTestResult | null>(null);
+
+	// Initialize form from connector config (only on mount)
+	useEffect(() => {
+		if (connector.name) {
+			setName(connector.name);
+		}
+		
+		const serverConfig = connector.config?.server_config as MCPServerConfig | undefined;
+		if (serverConfig) {
+			// Convert server config to JSON string for editing (name is in separate field)
+			const configObj = {
+				command: serverConfig.command || "",
+				args: serverConfig.args || [],
+				env: serverConfig.env || {},
+				transport: serverConfig.transport || "stdio",
+			};
+			setConfigJson(JSON.stringify(configObj, null, 2));
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, []); // Only run on mount to preserve user edits
+
+	const handleNameChange = (value: string) => {
+		setName(value);
+		if (onNameChange) {
+			onNameChange(value);
+		}
+	};
+
+	const parseConfig = () => {
+		const result = parseMCPConfig(configJson);
+		if (result.error) {
+			setJsonError(result.error);
+		} else {
+			setJsonError(null);
+		}
+		return result.config;
+	};
+
+	const handleConfigChange = (value: string) => {
+		setConfigJson(value);
+		if (jsonError) {
+			setJsonError(null);
+		}
+		
+		// Use shared utility for validation and parsing (with caching)
+		const result = parseMCPConfig(value);
+		
+		if (result.config && onConfigChange) {
+			// Valid config - update parent immediately
+			onConfigChange({ server_config: result.config });
+		}
+		// Ignore errors while typing - only show errors when user tests or saves
+	};
+
+	const handleTestConnection = async () => {
+		const serverConfig = parseConfig();
+		if (!serverConfig) {
+			setTestResult({
+				status: "error",
+				message: jsonError || "Invalid configuration",
+				tools: [],
+			});
+			return;
+		}
+
+		// Update parent with the config
+		if (onConfigChange) {
+			onConfigChange({ server_config: serverConfig });
+		}
+
+		setIsTesting(true);
+		setTestResult(null);
+
+		const result = await testMCPConnection(serverConfig);
+		setTestResult(result);
+		setIsTesting(false);
+	};
+
+	return (
+		<div className="space-y-6">
+			{/* Server Name */}
+			<div className="space-y-2">
+				<Label htmlFor="name">Server Name *</Label>
+				<Input
+					id="name"
+					value={name}
+					onChange={(e) => handleNameChange(e.target.value)}
+					placeholder="e.g., Filesystem Server"
+					required
+				/>
+			</div>
+
+			{/* Server Configuration */}
+			<div className="space-y-4">
+				<h3 className="font-medium text-sm sm:text-base flex items-center gap-2">
+					<Server className="h-4 w-4" />
+					Server Configuration
+				</h3>
+
+				<div className="rounded-xl border border-border bg-slate-400/5 dark:bg-white/5 p-3 sm:p-6 space-y-4">
+					<div className="space-y-2">
+						<Label htmlFor="config">MCP Server Configuration (JSON)</Label>
+						<Textarea
+							id="config"
+							value={configJson}
+							onChange={(e) => handleConfigChange(e.target.value)}
+							rows={16}
+							className={`font-mono text-xs ${jsonError ? "border-red-500" : ""}`}
+						/>
+						{jsonError && (
+							<p className="text-xs text-red-500">JSON Error: {jsonError}</p>
+						)}
+						<p className="text-[10px] sm:text-xs text-muted-foreground">
+							Edit your MCP server configuration. Must include: name, command, args (optional), env (optional), transport (optional).
+						</p>
+					</div>
+
+					{/* Test Connection */}
+					<div className="pt-4">
+						<Button
+							type="button"
+							onClick={handleTestConnection}
+							disabled={isTesting}
+							variant="outline"
+							className="w-full"
+						>
+							{isTesting ? "Testing Connection..." : "Test Connection"}
+						</Button>
+					</div>
+
+					{/* Test Result */}
+					{testResult && (
+						<Alert
+							className={
+								testResult.status === "success"
+									? "border-green-500/50 bg-green-500/10"
+									: "border-red-500/50 bg-red-500/10"
+							}
+						>
+							{testResult.status === "success" ? (
+								<CheckCircle2 className="h-4 w-4 text-green-600" />
+							) : (
+								<XCircle className="h-4 w-4 text-red-600" />
+							)}
+							<div className="flex-1">
+								<div className="flex items-center justify-between">
+									<AlertTitle className="text-sm">
+										{testResult.status === "success" ? "Connection Successful" : "Connection Failed"}
+									</AlertTitle>
+									{testResult.tools.length > 0 && (
+										<Button
+											type="button"
+											variant="ghost"
+											size="sm"
+											className="h-6 px-2"
+											onClick={(e) => {
+												e.preventDefault();
+												e.stopPropagation();
+												setShowDetails(!showDetails);
+											}}
+										>
+											{showDetails ? (
+												<>
+													<ChevronUp className="h-3 w-3 mr-1" />
+													Hide Details
+												</>
+											) : (
+												<>
+													<ChevronDown className="h-3 w-3 mr-1" />
+													Show Details
+												</>
+											)}
+										</Button>
+									)}
+								</div>
+								<AlertDescription className="text-xs mt-1">
+									{testResult.message}
+									{showDetails && testResult.tools.length > 0 && (
+										<div className="mt-3 pt-3 border-t border-green-500/20">
+											<p className="font-semibold mb-2">
+												Available tools:
+											</p>
+											<ul className="list-disc list-inside text-xs space-y-0.5">
+												{testResult.tools.map((tool, i) => (
+													<li key={i}>{tool.name}</li>
+												))}
+											</ul>
+										</div>
+									)}
+								</AlertDescription>
+							</div>
+						</Alert>
+					)}
+				</div>
+			</div>
+		</div>
+	);
+};

surfsense_web/components/assistant-ui/connector-popup/connector-configs/index.tsx

@@ -14,6 +14,7 @@ import { GoogleDriveConfig } from "./components/google-drive-config";
 import { JiraConfig } from "./components/jira-config";
 import { LinkupApiConfig } from "./components/linkup-api-config";
 import { LumaConfig } from "./components/luma-config";
+import { MCPConfig } from "./components/mcp-config";
 import { SearxngConfig } from "./components/searxng-config";
 import { SlackConfig } from "./components/slack-config";
 import { TavilyApiConfig } from "./components/tavily-api-config";
@@ -24,6 +25,7 @@ export interface ConnectorConfigProps {
 	connector: SearchSourceConnector;
 	onConfigChange?: (config: Record<string, unknown>) => void;
 	onNameChange?: (name: string) => void;
+	searchSpaceId?: string;
 }
 
 export type ConnectorConfigComponent = FC<ConnectorConfigProps>;
@@ -69,6 +71,8 @@ export function getConnectorConfigComponent(
 			return LumaConfig;
 		case "CIRCLEBACK_CONNECTOR":
 			return CirclebackConfig;
+		case "MCP_CONNECTOR":
+			return MCPConfig;
 		// OAuth connectors (Gmail, Calendar, Airtable, Notion) and others don't need special config UI
 		default:
 			return null;

surfsense_web/components/assistant-ui/connector-popup/connector-configs/views/connector-connect-view.tsx

@@ -56,6 +56,7 @@ export const ConnectorConnectView: FC<ConnectorConnectViewProps> = ({
 			GITHUB_CONNECTOR: "github-connect-form",
 			LUMA_CONNECTOR: "luma-connect-form",
 			CIRCLEBACK_CONNECTOR: "circleback-connect-form",
+			MCP_CONNECTOR: "mcp-connect-form",
 		};
 		const formId = formIdMap[connectorType];
 		if (formId) {
@@ -98,7 +99,7 @@ export const ConnectorConnectView: FC<ConnectorConnectViewProps> = ({
 					</div>
 					<div>
 						<h2 className="text-xl sm:text-2xl font-semibold tracking-tight">
-							Connect {getConnectorTypeDisplay(connectorType)}
+							Connect {connectorType === "MCP_CONNECTOR" ? "MCP Server" : getConnectorTypeDisplay(connectorType)}
 						</h2>
 						<p className="text-xs sm:text-base text-muted-foreground mt-1">
 							Enter your connection details
@@ -135,10 +136,10 @@ export const ConnectorConnectView: FC<ConnectorConnectViewProps> = ({
 					{isSubmitting ? (
 						<>
 							<Loader2 className="mr-2 h-4 w-4 animate-spin" />
-							Connecting...
+							Connecting
 						</>
 					) : (
-						<>Connect {getConnectorTypeDisplay(connectorType)}</>
+						<>{connectorType === "MCP_CONNECTOR" ? "Connect" : `Connect ${getConnectorTypeDisplay(connectorType)}`}</>
 					)}
 				</Button>
 			</div>

surfsense_web/components/assistant-ui/connector-popup/connector-configs/views/connector-edit-view.tsx

@@ -19,6 +19,7 @@ interface ConnectorEditViewProps {
 	isSaving: boolean;
 	isDisconnecting: boolean;
 	isIndexing?: boolean;
+	searchSpaceId?: string;
 	onStartDateChange: (date: Date | undefined) => void;
 	onEndDateChange: (date: Date | undefined) => void;
 	onPeriodicEnabledChange: (enabled: boolean) => void;
@@ -40,6 +41,7 @@ export const ConnectorEditView: FC<ConnectorEditViewProps> = ({
 	isSaving,
 	isDisconnecting,
 	isIndexing = false,
+	searchSpaceId,
 	onStartDateChange,
 	onEndDateChange,
 	onPeriodicEnabledChange,
@@ -149,7 +151,7 @@ export const ConnectorEditView: FC<ConnectorEditViewProps> = ({
 						</div>
 						<div className="flex-1 min-w-0">
 							<h2 className="text-xl sm:text-2xl font-semibold tracking-tight text-wrap whitespace-normal wrap-break-word">
-								{connector.name}
+						{connector.connector_type === "MCP_CONNECTOR" ? "MCP Server" : connector.name}
 							</h2>
 							<p className="text-xs sm:text-base text-muted-foreground mt-1">
 								Manage your connector settings and sync configuration
@@ -170,7 +172,7 @@ export const ConnectorEditView: FC<ConnectorEditViewProps> = ({
 								{isQuickIndexing || isIndexing ? (
 									<>
 										<RefreshCw className="mr-2 h-4 w-4 animate-spin" />
-										Indexing...
+										Syncing
 									</>
 								) : (
 									<>
@@ -197,6 +199,8 @@ export const ConnectorEditView: FC<ConnectorEditViewProps> = ({
 								connector={connector}
 								onConfigChange={onConfigChange}
 								onNameChange={onNameChange}
+								searchSpaceId={searchSpaceId}
+
 							/>
 						)}
 
@@ -218,15 +222,36 @@ export const ConnectorEditView: FC<ConnectorEditViewProps> = ({
 										/>
 									)}
 
-								{/* Periodic sync - not shown for Google Drive */}
-								{connector.connector_type !== "GOOGLE_DRIVE_CONNECTOR" && (
-									<PeriodicSyncConfig
-										enabled={periodicEnabled}
-										frequencyMinutes={frequencyMinutes}
-										onEnabledChange={onPeriodicEnabledChange}
-										onFrequencyChange={onFrequencyChange}
-									/>
-								)}
+								{/* Periodic sync - shown for all indexable connectors */}
+								{(() => {
+									// Check if Google Drive has folders/files selected
+									const isGoogleDrive = connector.connector_type === "GOOGLE_DRIVE_CONNECTOR";
+									const selectedFolders =
+										(connector.config?.selected_folders as
+											| Array<{ id: string; name: string }>
+											| undefined) || [];
+									const selectedFiles =
+										(connector.config?.selected_files as
+											| Array<{ id: string; name: string }>
+											| undefined) || [];
+									const hasItemsSelected = selectedFolders.length > 0 || selectedFiles.length > 0;
+									const isDisabled = isGoogleDrive && !hasItemsSelected;
+
+									return (
+										<PeriodicSyncConfig
+											enabled={periodicEnabled}
+											frequencyMinutes={frequencyMinutes}
+											onEnabledChange={onPeriodicEnabledChange}
+											onFrequencyChange={onFrequencyChange}
+											disabled={isDisabled}
+											disabledMessage={
+												isDisabled
+													? "Select at least one folder or file above to enable periodic sync"
+													: undefined
+											}
+										/>
+									);
+								})()}
 							</>
 						)}
 
@@ -277,7 +302,7 @@ export const ConnectorEditView: FC<ConnectorEditViewProps> = ({
 								{isDisconnecting ? (
 									<>
 										<Loader2 className="mr-2 h-4 w-4 animate-spin" />
-										Disconnecting...
+										Disconnecting
 									</>
 								) : (
 									"Confirm Disconnect"

surfsense_web/components/assistant-ui/connector-popup/constants/connector-constants.ts

@@ -160,6 +160,12 @@ export const OTHER_CONNECTORS = [
 		description: "Receive meeting notes, transcripts",
 		connectorType: EnumConnectorName.CIRCLEBACK_CONNECTOR,
 	},
+	{
+		id: "mcp-connector",
+		title: "MCPs",
+		description: "Connect to MCP servers for AI tools",
+		connectorType: EnumConnectorName.MCP_CONNECTOR,
+	},
 ] as const;
 
 // Re-export IndexingConfigState from schemas for backward compatibility

surfsense_web/components/assistant-ui/connector-popup/constants/connector-popup.schemas.ts

@@ -7,7 +7,7 @@ import { searchSourceConnectorTypeEnum } from "@/contracts/types/connector.types
 export const connectorPopupQueryParamsSchema = z.object({
 	modal: z.enum(["connectors"]).optional(),
 	tab: z.enum(["all", "active"]).optional(),
-	view: z.enum(["configure", "edit", "connect", "youtube", "accounts"]).optional(),
+	view: z.enum(["configure", "edit", "connect", "youtube", "accounts", "mcp-list"]).optional(),
 	connector: z.string().optional(),
 	connectorId: z.string().optional(),
 	connectorType: z.string().optional(),

surfsense_web/components/assistant-ui/connector-popup/hooks/use-connector-dialog.ts

@@ -80,12 +80,18 @@ export const useConnectorDialog = () => {
 		connectorTitle: string;
 	} | null>(null);
 
+	// MCP list view state (for managing multiple MCP connectors)
+	const [viewingMCPList, setViewingMCPList] = useState(false);
+
 	// Track if we came from accounts list when entering edit mode
 	const [cameFromAccountsList, setCameFromAccountsList] = useState<{
 		connectorType: string;
 		connectorTitle: string;
 	} | null>(null);
 
+	// Track if we came from MCP list view when entering edit mode
+	const [cameFromMCPList, setCameFromMCPList] = useState(false);
+
 	// Helper function to get frequency label
 	const getFrequencyLabel = useCallback((minutes: string): string => {
 		switch (minutes) {
@@ -139,6 +145,16 @@ export const useConnectorDialog = () => {
 					setViewingAccountsType(null);
 				}
 
+				// Clear MCP list view if view is not "mcp-list" anymore
+				if (params.view !== "mcp-list" && viewingMCPList) {
+					setViewingMCPList(false);
+				}
+
+				// Handle MCP list view
+				if (params.view === "mcp-list" && !viewingMCPList) {
+					setViewingMCPList(true);
+				}
+
 				// Handle connect view
 				if (params.view === "connect" && params.connectorType && !connectingConnectorType) {
 					setConnectingConnectorType(params.connectorType);
@@ -203,11 +219,9 @@ export const useConnectorDialog = () => {
 							setEditingConnector(connector);
 							setConnectorConfig(connector.config);
 							setConnectorName(connector.name);
-							// Load existing periodic sync settings (disabled for Google Drive and non-indexable connectors)
+							// Load existing periodic sync settings (disabled for non-indexable connectors)
 							setPeriodicEnabled(
-								connector.connector_type === "GOOGLE_DRIVE_CONNECTOR" || !connector.is_indexable
-									? false
-									: connector.periodic_indexing_enabled
+								!connector.is_indexable ? false : connector.periodic_indexing_enabled
 							);
 							setFrequencyMinutes(connector.indexing_frequency_minutes?.toString() || "1440");
 							// Reset dates - user can set new ones for re-indexing
@@ -421,6 +435,7 @@ export const useConnectorDialog = () => {
 					connector_type: EnumConnectorName.WEBCRAWLER_CONNECTOR,
 					config: {},
 					is_indexable: true,
+					is_active: true,
 					last_indexed_at: null,
 					periodic_indexing_enabled: false,
 					indexing_frequency_minutes: null,
@@ -491,20 +506,23 @@ export const useConnectorDialog = () => {
 
 	// Handle submitting connect form
 	const handleSubmitConnectForm = useCallback(
-		async (formData: {
-			name: string;
-			connector_type: string;
-			config: Record<string, unknown>;
-			is_indexable: boolean;
-			last_indexed_at: null;
-			periodic_indexing_enabled: boolean;
-			indexing_frequency_minutes: number | null;
-			next_scheduled_at: null;
-			startDate?: Date;
-			endDate?: Date;
-			periodicEnabled?: boolean;
-			frequencyMinutes?: string;
-		}) => {
+		async (
+			formData: {
+				name: string;
+				connector_type: string;
+				config: Record<string, unknown>;
+				is_indexable: boolean;
+				last_indexed_at: null;
+				periodic_indexing_enabled: boolean;
+				indexing_frequency_minutes: number | null;
+				next_scheduled_at: null;
+				startDate?: Date;
+				endDate?: Date;
+				periodicEnabled?: boolean;
+				frequencyMinutes?: string;
+			},
+			onIndexingStart?: (connectorId: number) => void
+		) => {
 			if (!searchSpaceId || !connectingConnectorType) return;
 
 			// Prevent multiple submissions using ref for immediate check
@@ -522,17 +540,18 @@ export const useConnectorDialog = () => {
 					data: {
 						...connectorData,
 						connector_type: connectorData.connector_type as EnumConnectorName,
-						next_scheduled_at: connectorData.next_scheduled_at as string | null,
-					},
-					queryParams: {
-						search_space_id: searchSpaceId,
-					},
-				});
+					is_active: true,
+					next_scheduled_at: connectorData.next_scheduled_at as string | null,
+				},
+				queryParams: {
+					search_space_id: searchSpaceId,
+				},
+			});
 
-				// Refetch connectors to get the new one
-				const result = await refetchAllConnectors();
-				if (result.data) {
-					const connector = result.data.find(
+			// Refetch connectors to get the new one
+			const result = await refetchAllConnectors();
+			if (result.data) {
+				const connector = result.data.find(
 						(c: SearchSourceConnector) => c.id === newConnector.id
 					);
 					if (connector) {
@@ -603,6 +622,11 @@ export const useConnectorDialog = () => {
 									});
 								}
 
+								// Notify caller that indexing is starting (for UI syncing state)
+								if (onIndexingStart) {
+									onIndexingStart(connector.id);
+								}
+
 								// Start indexing (backend will use defaults if dates are undefined)
 								const startDateStr = startDateForIndexing
 									? format(startDateForIndexing, "yyyy-MM-dd")
@@ -620,32 +644,34 @@ export const useConnectorDialog = () => {
 									},
 								});
 
-								toast.success(`${connectorTitle} connected and indexing started!`, {
-									description: periodicEnabledForIndexing
-										? `Periodic sync enabled every ${getFrequencyLabel(frequencyMinutesForIndexing)}.`
-										: "You can continue working while we sync your data.",
-								});
+							const successMessage = currentConnectorType === "MCP_CONNECTOR"
+								? `${connector.name} MCP server added successfully`
+								: `${connectorTitle} connected and indexing started!`;
+							toast.success(successMessage, {
+								description: periodicEnabledForIndexing
+									? `Periodic sync enabled every ${getFrequencyLabel(frequencyMinutesForIndexing)}.`
+									: "You can continue working while we sync your data.",
+							});
 
-								// Close modal and return to main view
-								const url = new URL(window.location.href);
-								url.searchParams.delete("modal");
-								url.searchParams.delete("tab");
-								url.searchParams.delete("view");
-								url.searchParams.delete("connectorType");
-								router.replace(url.pathname + url.search, { scroll: false });
+							const url = new URL(window.location.href);
+							url.searchParams.delete("modal");
+							url.searchParams.delete("tab");
+							url.searchParams.delete("view");
+							url.searchParams.delete("connectorType");
+							router.replace(url.pathname + url.search, { scroll: false });
 
-								// Clear indexing config state since we're not showing the view
-								setIndexingConfig(null);
-								setIndexingConnector(null);
-								setIndexingConnectorConfig(null);
+							// Clear indexing config state since we're not showing the view
+							setIndexingConfig(null);
+							setIndexingConnector(null);
+							setIndexingConnectorConfig(null);
 
-								// Invalidate queries to refresh data
-								queryClient.invalidateQueries({
-									queryKey: cacheKeys.logs.summary(Number(searchSpaceId)),
-								});
+							// Invalidate queries to refresh data
+							queryClient.invalidateQueries({
+								queryKey: cacheKeys.logs.summary(Number(searchSpaceId)),
+							});
 
-								// Refresh connectors list
-								await refetchAllConnectors();
+							// Refresh connectors list
+							await refetchAllConnectors();
 							} else {
 								// Non-indexable connector
 								// For Circleback, transition to edit view to show webhook URL
@@ -682,7 +708,13 @@ export const useConnectorDialog = () => {
 									await refetchAllConnectors();
 								} else {
 									// Other non-indexable connectors - just show success message and close
-									toast.success(`${connectorTitle} connected successfully!`);
+									const successMessage = currentConnectorType === "MCP_CONNECTOR"
+										? `${connector.name} MCP server added successfully`
+										: `${connectorTitle} connected successfully!`;
+									toast.success(successMessage);
+
+									// Refresh connectors list before closing modal
+									await refetchAllConnectors();
 
 									// Close modal and return to main view
 									const url = new URL(window.location.href);
@@ -726,11 +758,18 @@ export const useConnectorDialog = () => {
 	const handleBackFromConnect = useCallback(() => {
 		const url = new URL(window.location.href);
 		url.searchParams.set("modal", "connectors");
-		url.searchParams.set("tab", "all");
-		url.searchParams.delete("view");
+		
+		// If we're connecting an MCP and came from list view, go back to list
+		if (connectingConnectorType === "MCP_CONNECTOR" && viewingMCPList) {
+			url.searchParams.set("view", "mcp-list");
+		} else {
+			url.searchParams.set("tab", "all");
+			url.searchParams.delete("view");
+		}
+		
 		url.searchParams.delete("connectorType");
 		router.replace(url.pathname + url.search, { scroll: false });
-	}, [router]);
+	}, [router, connectingConnectorType, viewingMCPList]);
 
 	// Handle going back from YouTube view
 	const handleBackFromYouTube = useCallback(() => {
@@ -773,6 +812,38 @@ export const useConnectorDialog = () => {
 		router.replace(url.pathname + url.search, { scroll: false });
 	}, [router]);
 
+	// Handle viewing MCP list
+	const handleViewMCPList = useCallback(() => {
+		if (!searchSpaceId) return;
+
+		setViewingMCPList(true);
+
+		// Update URL to show MCP list view
+		const url = new URL(window.location.href);
+		url.searchParams.set("modal", "connectors");
+		url.searchParams.set("view", "mcp-list");
+		window.history.pushState({ modal: true }, "", url.toString());
+	}, [searchSpaceId]);
+
+	// Handle going back from MCP list view
+	const handleBackFromMCPList = useCallback(() => {
+		setViewingMCPList(false);
+		const url = new URL(window.location.href);
+		url.searchParams.set("modal", "connectors");
+		url.searchParams.delete("view");
+		router.replace(url.pathname + url.search, { scroll: false });
+	}, [router]);
+
+	// Handle adding new MCP from list view
+	const handleAddNewMCPFromList = useCallback(() => {
+		setConnectingConnectorType("MCP_CONNECTOR");
+		const url = new URL(window.location.href);
+		url.searchParams.set("modal", "connectors");
+		url.searchParams.set("view", "connect");
+		url.searchParams.set("connectorType", "MCP_CONNECTOR");
+		router.replace(url.pathname + url.search, { scroll: false });
+	}, [router]);
+
 	// Handle starting indexing
 	const handleStartIndexing = useCallback(
 		async (refreshConnectors: () => void) => {
@@ -809,20 +880,14 @@ export const useConnectorDialog = () => {
 				const endDateStr = endDate ? format(endDate, "yyyy-MM-dd") : undefined;
 
 				// Update connector with periodic sync settings and config changes
-				// Note: Periodic sync is disabled for Google Drive connectors
 				if (periodicEnabled || indexingConnectorConfig) {
 					const frequency = periodicEnabled ? parseInt(frequencyMinutes, 10) : undefined;
 					await updateConnector({
 						id: indexingConfig.connectorId,
 						data: {
-							...(periodicEnabled &&
-								indexingConfig.connectorType !== "GOOGLE_DRIVE_CONNECTOR" && {
-									periodic_indexing_enabled: true,
-									indexing_frequency_minutes: frequency,
-								}),
-							...(indexingConfig.connectorType === "GOOGLE_DRIVE_CONNECTOR" && {
-								periodic_indexing_enabled: false,
-								indexing_frequency_minutes: null,
+							...(periodicEnabled && {
+								periodic_indexing_enabled: true,
+								indexing_frequency_minutes: frequency,
 							}),
 							...(indexingConnectorConfig && {
 								config: indexingConnectorConfig,
@@ -839,11 +904,18 @@ export const useConnectorDialog = () => {
 					const selectedFiles = indexingConnectorConfig.selected_files as
 						| Array<{ id: string; name: string }>
 						| undefined;
+					const indexingOptions = indexingConnectorConfig.indexing_options as
+						| {
+								max_files_per_folder: number;
+								incremental_sync: boolean;
+								include_subfolders: boolean;
+						  }
+						| undefined;
 					if (
 						(selectedFolders && selectedFolders.length > 0) ||
 						(selectedFiles && selectedFiles.length > 0)
 					) {
-						// Index with folder/file selection
+						// Index with folder/file selection and indexing options
 						await indexConnector({
 							connector_id: indexingConfig.connectorId,
 							queryParams: {
@@ -852,6 +924,11 @@ export const useConnectorDialog = () => {
 							body: {
 								folders: selectedFolders || [],
 								files: selectedFiles || [],
+								indexing_options: indexingOptions || {
+									max_files_per_folder: 100,
+									incremental_sync: true,
+									include_subfolders: true,
+								},
 							},
 						});
 					} else {
@@ -891,7 +968,7 @@ export const useConnectorDialog = () => {
 				);
 
 				// Track periodic indexing started if enabled
-				if (periodicEnabled && indexingConfig.connectorType !== "GOOGLE_DRIVE_CONNECTOR") {
+				if (periodicEnabled) {
 					trackPeriodicIndexingStarted(
 						Number(searchSpaceId),
 						indexingConfig.connectorType,
@@ -958,6 +1035,13 @@ export const useConnectorDialog = () => {
 		(connector: SearchSourceConnector) => {
 			if (!searchSpaceId) return;
 
+			// For MCP connectors from "All Connectors" tab, show the list view instead of directly editing
+			// (unless we're already in the MCP list view or on the Active tab where individual MCPs are shown)
+			if (connector.connector_type === "MCP_CONNECTOR" && !viewingMCPList && activeTab === "all") {
+				handleViewMCPList();
+				return;
+			}
+
 			// All connector types should be handled in the popup edit view
 			// Validate connector data
 			const connectorValidation = searchSourceConnector.safeParse(connector);
@@ -974,6 +1058,13 @@ export const useConnectorDialog = () => {
 				setCameFromAccountsList(null);
 			}
 
+			// Track if we came from MCP list view
+			if (viewingMCPList && connector.connector_type === "MCP_CONNECTOR") {
+				setCameFromMCPList(true);
+			} else {
+				setCameFromMCPList(false);
+			}
+
 			// Track index with date range opened event
 			if (connector.is_indexable) {
 				trackIndexWithDateRangeOpened(
@@ -985,12 +1076,8 @@ export const useConnectorDialog = () => {
 
 			setEditingConnector(connector);
 			setConnectorName(connector.name);
-			// Load existing periodic sync settings (disabled for Google Drive and non-indexable connectors)
-			setPeriodicEnabled(
-				connector.connector_type === "GOOGLE_DRIVE_CONNECTOR" || !connector.is_indexable
-					? false
-					: connector.periodic_indexing_enabled
-			);
+			// Load existing periodic sync settings (disabled for non-indexable connectors)
+			setPeriodicEnabled(!connector.is_indexable ? false : connector.periodic_indexing_enabled);
 			setFrequencyMinutes(connector.indexing_frequency_minutes?.toString() || "1440");
 			// Reset dates - user can set new ones for re-indexing
 			setStartDate(undefined);
@@ -1003,13 +1090,13 @@ export const useConnectorDialog = () => {
 			url.searchParams.set("connectorId", connector.id.toString());
 			window.history.pushState({ modal: true }, "", url.toString());
 		},
-		[searchSpaceId, viewingAccountsType]
+		[searchSpaceId, viewingAccountsType, viewingMCPList, handleViewMCPList, activeTab]
 	);
 
 	// Handle saving connector changes
 	const handleSaveConnector = useCallback(
 		async (refreshConnectors: () => void) => {
-			if (!editingConnector || !searchSpaceId) return;
+			if (!editingConnector || !searchSpaceId || isSaving) return;
 
 			// Validate date range (skip for Google Drive which uses folder selection, Webcrawler which uses config, and non-indexable connectors)
 			if (
@@ -1030,6 +1117,24 @@ export const useConnectorDialog = () => {
 				return;
 			}
 
+			// Prevent periodic indexing for Google Drive without folders/files selected
+			if (periodicEnabled && editingConnector.connector_type === "GOOGLE_DRIVE_CONNECTOR") {
+				const selectedFolders = (connectorConfig || editingConnector.config)?.selected_folders as
+					| Array<{ id: string; name: string }>
+					| undefined;
+				const selectedFiles = (connectorConfig || editingConnector.config)?.selected_files as
+					| Array<{ id: string; name: string }>
+					| undefined;
+				const hasItemsSelected =
+					(selectedFolders && selectedFolders.length > 0) ||
+					(selectedFiles && selectedFiles.length > 0);
+
+				if (!hasItemsSelected) {
+					toast.error("Select at least one folder or file to enable periodic sync");
+					return;
+				}
+			}
+
 			// Validate frequency minutes if periodic is enabled (only for indexable connectors)
 			if (periodicEnabled && editingConnector.is_indexable) {
 				const frequencyValidation = frequencyMinutesSchema.safeParse(frequencyMinutes);
@@ -1045,23 +1150,14 @@ export const useConnectorDialog = () => {
 				const endDateStr = endDate ? format(endDate, "yyyy-MM-dd") : undefined;
 
 				// Update connector with periodic sync settings, config changes, and name
-				// Note: Periodic sync is disabled for Google Drive connectors and non-indexable connectors
 				const frequency =
 					periodicEnabled && editingConnector.is_indexable ? parseInt(frequencyMinutes, 10) : null;
 				await updateConnector({
 					id: editingConnector.id,
 					data: {
 						name: connectorName || editingConnector.name,
-						periodic_indexing_enabled:
-							editingConnector.connector_type === "GOOGLE_DRIVE_CONNECTOR" ||
-							!editingConnector.is_indexable
-								? false
-								: periodicEnabled,
-						indexing_frequency_minutes:
-							editingConnector.connector_type === "GOOGLE_DRIVE_CONNECTOR" ||
-							!editingConnector.is_indexable
-								? null
-								: frequency,
+						periodic_indexing_enabled: !editingConnector.is_indexable ? false : periodicEnabled,
+						indexing_frequency_minutes: !editingConnector.is_indexable ? null : frequency,
 						config: connectorConfig || editingConnector.config,
 					},
 				});
@@ -1079,6 +1175,13 @@ export const useConnectorDialog = () => {
 					const selectedFiles = (connectorConfig || editingConnector.config)?.selected_files as
 						| Array<{ id: string; name: string }>
 						| undefined;
+					const indexingOptions = (connectorConfig || editingConnector.config)?.indexing_options as
+						| {
+								max_files_per_folder: number;
+								incremental_sync: boolean;
+								include_subfolders: boolean;
+						  }
+						| undefined;
 					if (
 						(selectedFolders && selectedFolders.length > 0) ||
 						(selectedFiles && selectedFiles.length > 0)
@@ -1091,6 +1194,11 @@ export const useConnectorDialog = () => {
 							body: {
 								folders: selectedFolders || [],
 								files: selectedFiles || [],
+								indexing_options: indexingOptions || {
+									max_files_per_folder: 100,
+									incremental_sync: true,
+									include_subfolders: true,
+								},
 							},
 						});
 						const totalItems = (selectedFolders?.length || 0) + (selectedFiles?.length || 0);
@@ -1134,12 +1242,8 @@ export const useConnectorDialog = () => {
 					);
 				}
 
-				// Track periodic indexing if enabled (for non-Google Drive connectors)
-				if (
-					periodicEnabled &&
-					editingConnector.is_indexable &&
-					editingConnector.connector_type !== "GOOGLE_DRIVE_CONNECTOR"
-				) {
+				// Track periodic indexing if enabled
+				if (periodicEnabled && editingConnector.is_indexable) {
 					trackPeriodicIndexingStarted(
 						Number(searchSpaceId),
 						editingConnector.connector_type,
@@ -1148,34 +1252,38 @@ export const useConnectorDialog = () => {
 					);
 				}
 
-				toast.success(`${editingConnector.name} updated successfully`, {
-					description: periodicEnabled
-						? `Periodic sync ${frequency ? `enabled every ${getFrequencyLabel(frequencyMinutes)}` : "enabled"}. ${indexingDescription}`
-						: indexingDescription,
-				});
+			// Generate toast message based on connector type
+			const toastTitle = `${editingConnector.name} updated successfully`;
 
-				// Update URL - the effect will handle closing the modal and clearing state
-				const url = new URL(window.location.href);
-				url.searchParams.delete("modal");
-				url.searchParams.delete("tab");
-				url.searchParams.delete("view");
-				url.searchParams.delete("connectorId");
-				router.replace(url.pathname + url.search, { scroll: false });
+			toast.success(toastTitle, {
+				description: periodicEnabled
+					? `Periodic sync ${frequency ? `enabled every ${getFrequencyLabel(frequencyMinutes)}` : "enabled"}. ${indexingDescription}`
+					: indexingDescription,
+			});
 
-				refreshConnectors();
-				queryClient.invalidateQueries({
-					queryKey: cacheKeys.logs.summary(Number(searchSpaceId)),
-				});
-			} catch (error) {
-				console.error("Error saving connector:", error);
-				toast.error("Failed to save connector changes");
-			} finally {
-				setIsSaving(false);
-			}
+			// Update URL - the effect will handle closing the modal and clearing state
+			const url = new URL(window.location.href);
+			url.searchParams.delete("modal");
+			url.searchParams.delete("tab");
+			url.searchParams.delete("view");
+			url.searchParams.delete("connectorId");
+			router.replace(url.pathname + url.search, { scroll: false });
+
+			refreshConnectors();
+			queryClient.invalidateQueries({
+				queryKey: cacheKeys.logs.summary(Number(searchSpaceId)),
+			});
+		} catch (error) {
+			console.error("Error saving connector:", error);
+			toast.error("Failed to save connector changes");
+		} finally {
+			setIsSaving(false);
+		}
 		},
 		[
 			editingConnector,
 			searchSpaceId,
+			isSaving,
 			startDate,
 			endDate,
 			indexConnector,
@@ -1207,14 +1315,27 @@ export const useConnectorDialog = () => {
 					editingConnector.id
 				);
 
-				toast.success(`${editingConnector.name} disconnected successfully`);
+				toast.success(
+					editingConnector.connector_type === "MCP_CONNECTOR"
+						? `${editingConnector.name} MCP server removed successfully`
+						: `${editingConnector.name} disconnected successfully`
+				);
 
-				// Update URL - the effect will handle closing the modal and clearing state
+				// Update URL - for MCP from list view, go back to list; otherwise close modal
 				const url = new URL(window.location.href);
-				url.searchParams.delete("modal");
-				url.searchParams.delete("tab");
-				url.searchParams.delete("view");
-				url.searchParams.delete("connectorId");
+				if (editingConnector.connector_type === "MCP_CONNECTOR" && cameFromMCPList) {
+					// Go back to MCP list view only if we came from there
+					setViewingMCPList(true);
+					url.searchParams.set("modal", "connectors");
+					url.searchParams.set("view", "mcp-list");
+					url.searchParams.delete("connectorId");
+				} else {
+					// Close modal for all other cases
+					url.searchParams.delete("modal");
+					url.searchParams.delete("tab");
+					url.searchParams.delete("view");
+					url.searchParams.delete("connectorId");
+				}
 				router.replace(url.pathname + url.search, { scroll: false });
 
 				refreshConnectors();
@@ -1266,6 +1387,21 @@ export const useConnectorDialog = () => {
 
 	// Handle going back from edit view
 	const handleBackFromEdit = useCallback(() => {
+		// If editing an MCP connector and came from MCP list, go back to MCP list view
+		if (editingConnector?.connector_type === "MCP_CONNECTOR" && cameFromMCPList) {
+			setViewingMCPList(true);
+			setCameFromMCPList(false);
+			const url = new URL(window.location.href);
+			url.searchParams.set("modal", "connectors");
+			url.searchParams.set("view", "mcp-list");
+			url.searchParams.delete("connectorId");
+			router.replace(url.pathname + url.search, { scroll: false });
+			setEditingConnector(null);
+			setConnectorName(null);
+			setConnectorConfig(null);
+			return;
+		}
+
 		// If we came from accounts list view, go back there
 		if (cameFromAccountsList && editingConnector) {
 			// Restore accounts list view
@@ -1278,10 +1414,10 @@ export const useConnectorDialog = () => {
 			url.searchParams.delete("connectorId");
 			router.replace(url.pathname + url.search, { scroll: false });
 		} else {
-			// Otherwise, go back to main connector popup
+			// Otherwise, go back to main connector popup (preserve the tab the user was on)
 			const url = new URL(window.location.href);
 			url.searchParams.set("modal", "connectors");
-			url.searchParams.set("tab", "all");
+			url.searchParams.set("tab", activeTab); // Use current tab instead of always "all"
 			url.searchParams.delete("view");
 			url.searchParams.delete("connectorId");
 			router.replace(url.pathname + url.search, { scroll: false });
@@ -1289,7 +1425,7 @@ export const useConnectorDialog = () => {
 		setEditingConnector(null);
 		setConnectorName(null);
 		setConnectorConfig(null);
-	}, [router, cameFromAccountsList, editingConnector]);
+	}, [router, cameFromAccountsList, editingConnector, cameFromMCPList, activeTab]);
 
 	// Handle dialog open/close
 	const handleOpenChange = useCallback(
@@ -1367,6 +1503,7 @@ export const useConnectorDialog = () => {
 		searchSpaceId,
 		allConnectors,
 		viewingAccountsType,
+		viewingMCPList,
 
 		// Setters
 		setSearchQuery,
@@ -1395,6 +1532,9 @@ export const useConnectorDialog = () => {
 		handleBackFromYouTube,
 		handleViewAccountsList,
 		handleBackFromAccountsList,
+		handleViewMCPList,
+		handleBackFromMCPList,
+		handleAddNewMCPFromList,
 		handleQuickIndexConnector,
 		connectorConfig,
 		setConnectorConfig,

surfsense_web/components/assistant-ui/connector-popup/hooks/use-connector-status.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useMemo } from "react";
+import { useCallback, useMemo } from "react";
 import {
 	type ConnectorStatusConfig,
 	connectorStatusConfig,
@@ -14,34 +14,43 @@ export function useConnectorStatus() {
 	/**
 	 * Get status configuration for a specific connector type
 	 */
-	const getConnectorStatus = (connectorType: string | undefined): ConnectorStatusConfig => {
-		if (!connectorType) {
-			return getDefaultConnectorStatus();
-		}
+	const getConnectorStatus = useCallback(
+		(connectorType: string | undefined): ConnectorStatusConfig => {
+			if (!connectorType) {
+				return getDefaultConnectorStatus();
+			}
 
-		return connectorStatusConfig.connectorStatuses[connectorType] || getDefaultConnectorStatus();
-	};
+			return connectorStatusConfig.connectorStatuses[connectorType] || getDefaultConnectorStatus();
+		},
+		[]
+	);
 
 	/**
 	 * Check if a connector is enabled
 	 */
-	const isConnectorEnabled = (connectorType: string | undefined): boolean => {
-		return getConnectorStatus(connectorType).enabled;
-	};
+	const isConnectorEnabled = useCallback(
+		(connectorType: string | undefined): boolean => {
+			return getConnectorStatus(connectorType).enabled;
+		},
+		[getConnectorStatus]
+	);
 
 	/**
 	 * Get status message for a connector
 	 */
-	const getConnectorStatusMessage = (connectorType: string | undefined): string | null => {
-		return getConnectorStatus(connectorType).statusMessage || null;
-	};
+	const getConnectorStatusMessage = useCallback(
+		(connectorType: string | undefined): string | null => {
+			return getConnectorStatus(connectorType).statusMessage || null;
+		},
+		[getConnectorStatus]
+	);
 
 	/**
 	 * Check if warnings should be shown globally
 	 */
-	const shouldShowWarnings = (): boolean => {
+	const shouldShowWarnings = useCallback((): boolean => {
 		return connectorStatusConfig.globalSettings.showWarnings;
-	};
+	}, []);
 
 	return useMemo(
 		() => ({
@@ -50,6 +59,6 @@ export function useConnectorStatus() {
 			getConnectorStatusMessage,
 			shouldShowWarnings,
 		}),
-		[]
+		[getConnectorStatus, isConnectorEnabled, getConnectorStatusMessage, shouldShowWarnings]
 	);
 }

surfsense_web/components/assistant-ui/connector-popup/hooks/use-indexing-connectors.ts

@@ -0,0 +1,81 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { SearchSourceConnector } from "@/contracts/types/connector.types";
+
+/**
+ * Hook to track which connectors are currently indexing using local state.
+ *
+ * This provides a better UX than polling by:
+ * 1. Setting indexing state immediately when user triggers indexing (optimistic)
+ * 2. Clearing indexing state when Electric SQL detects last_indexed_at changed
+ *
+ * The actual `last_indexed_at` value comes from Electric SQL/PGlite, not local state.
+ */
+export function useIndexingConnectors(connectors: SearchSourceConnector[]) {
+	// Set of connector IDs that are currently indexing
+	const [indexingConnectorIds, setIndexingConnectorIds] = useState<Set<number>>(new Set());
+
+	// Track previous last_indexed_at values to detect changes
+	const previousLastIndexedAtRef = useRef<Map<number, string | null>>(new Map());
+
+	// Detect when last_indexed_at changes (indexing completed) via Electric SQL
+	useEffect(() => {
+		const previousValues = previousLastIndexedAtRef.current;
+		const newIndexingIds = new Set(indexingConnectorIds);
+		let hasChanges = false;
+
+		for (const connector of connectors) {
+			const previousValue = previousValues.get(connector.id);
+			const currentValue = connector.last_indexed_at;
+
+			// If last_indexed_at changed and connector was in indexing state, clear it
+			if (
+				previousValue !== undefined && // We've seen this connector before
+				previousValue !== currentValue && // Value changed
+				indexingConnectorIds.has(connector.id) // It was marked as indexing
+			) {
+				newIndexingIds.delete(connector.id);
+				hasChanges = true;
+			}
+
+			// Update previous value tracking
+			previousValues.set(connector.id, currentValue);
+		}
+
+		if (hasChanges) {
+			setIndexingConnectorIds(newIndexingIds);
+		}
+	}, [connectors, indexingConnectorIds]);
+
+	// Add a connector to the indexing set (called when indexing starts)
+	const startIndexing = useCallback((connectorId: number) => {
+		setIndexingConnectorIds((prev) => {
+			const next = new Set(prev);
+			next.add(connectorId);
+			return next;
+		});
+	}, []);
+
+	// Remove a connector from the indexing set (called manually if needed)
+	const stopIndexing = useCallback((connectorId: number) => {
+		setIndexingConnectorIds((prev) => {
+			const next = new Set(prev);
+			next.delete(connectorId);
+			return next;
+		});
+	}, []);
+
+	// Check if a connector is currently indexing
+	const isIndexing = useCallback(
+		(connectorId: number) => indexingConnectorIds.has(connectorId),
+		[indexingConnectorIds]
+	);
+
+	return {
+		indexingConnectorIds,
+		startIndexing,
+		stopIndexing,
+		isIndexing,
+	};
+}

surfsense_web/components/assistant-ui/connector-popup/tabs/active-connectors-tab.tsx

@@ -1,15 +1,17 @@
 "use client";
 
-import { differenceInDays, differenceInMinutes, format, isToday, isYesterday } from "date-fns";
 import { ArrowRight, Cable, Loader2 } from "lucide-react";
 import { useRouter } from "next/navigation";
 import type { FC } from "react";
+import { useState } from "react";
 import { getDocumentTypeLabel } from "@/app/dashboard/[search_space_id]/documents/(manage)/components/DocumentTypeIcon";
 import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
 import { TabsContent } from "@/components/ui/tabs";
 import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
 import type { SearchSourceConnector } from "@/contracts/types/connector.types";
 import type { LogActiveTask, LogSummary } from "@/contracts/types/log.types";
+import { connectorsApiService } from "@/lib/apis/connectors-api.service";
 import { cn } from "@/lib/utils";
 import { OAUTH_CONNECTORS } from "../constants/connector-constants";
 import { getDocumentCountForConnector } from "../utils/connector-document-mapping";
@@ -21,20 +23,26 @@ interface ActiveConnectorsTabProps {
 	activeDocumentTypes: Array<[string, number]>;
 	connectors: SearchSourceConnector[];
 	indexingConnectorIds: Set<number>;
-	logsSummary: LogSummary | undefined;
 	searchSpaceId: string;
 	onTabChange: (value: string) => void;
 	onManage?: (connector: SearchSourceConnector) => void;
 	onViewAccountsList?: (connectorType: string, connectorTitle: string) => void;
 }
 
+/**
+ * Check if a connector type is indexable
+ */
+function isIndexableConnector(connectorType: string): boolean {
+	const nonIndexableTypes = ["MCP_CONNECTOR"];
+	return !nonIndexableTypes.includes(connectorType);
+}
+
 export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 	searchQuery,
 	hasSources,
 	activeDocumentTypes,
 	connectors,
 	indexingConnectorIds,
-	logsSummary,
 	searchSpaceId,
 	onTabChange,
 	onManage,
@@ -67,32 +75,6 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 		return `${m.replace(/\.0$/, "")}M docs`;
 	};
 
-	// Format last indexed date with contextual messages
-	const formatLastIndexedDate = (dateString: string): string => {
-		const date = new Date(dateString);
-		const now = new Date();
-		const minutesAgo = differenceInMinutes(now, date);
-		const daysAgo = differenceInDays(now, date);
-
-		if (minutesAgo < 1) return "Just now";
-		if (minutesAgo < 60) return `${minutesAgo} ${minutesAgo === 1 ? "minute" : "minutes"} ago`;
-		if (isToday(date)) return `Today at ${format(date, "h:mm a")}`;
-		if (isYesterday(date)) return `Yesterday at ${format(date, "h:mm a")}`;
-		if (daysAgo < 7) return `${daysAgo} ${daysAgo === 1 ? "day" : "days"} ago`;
-		return format(date, "MMM d, yyyy");
-	};
-
-	// Get most recent last indexed date from a list of connectors
-	const getMostRecentLastIndexed = (
-		connectorsList: SearchSourceConnector[]
-	): string | undefined => {
-		return connectorsList.reduce<string | undefined>((latest, c) => {
-			if (!c.last_indexed_at) return latest;
-			if (!latest) return c.last_indexed_at;
-			return new Date(c.last_indexed_at) > new Date(latest) ? c.last_indexed_at : latest;
-		}, undefined);
-	};
-
 	// Document types that should be shown as standalone cards (not from connectors)
 	const standaloneDocumentTypes = ["EXTENSION", "FILE", "NOTE", "YOUTUBE_VIDEO", "CRAWLED_URL"];
 
@@ -114,7 +96,9 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 
 	// Separate OAuth and non-OAuth connectors
 	const oauthConnectors = connectors.filter((c) => oauthConnectorTypes.has(c.connector_type));
-	const nonOauthConnectors = connectors.filter((c) => !oauthConnectorTypes.has(c.connector_type));
+	const nonOauthConnectors = connectors.filter(
+		(c) => !oauthConnectorTypes.has(c.connector_type)
+	);
 
 	// Group OAuth connectors by type
 	const oauthConnectorsByType = oauthConnectors.reduce(
@@ -166,7 +150,8 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 	});
 
 	const hasActiveConnectors =
-		filteredOAuthConnectorTypes.length > 0 || filteredNonOAuthConnectors.length > 0;
+		filteredOAuthConnectorTypes.length > 0 ||
+		filteredNonOAuthConnectors.length > 0;
 
 	return (
 		<TabsContent value="active" className="m-0">
@@ -190,7 +175,6 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 										documentTypeCounts
 									);
 									const accountCount = typeConnectors.length;
-									const mostRecentLastIndexed = getMostRecentLastIndexed(typeConnectors);
 
 									const handleManageClick = () => {
 										if (onViewAccountsList) {
@@ -204,10 +188,10 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 										<div
 											key={`oauth-type-${connectorType}`}
 											className={cn(
-												"relative flex items-center gap-4 p-4 rounded-xl border border-border transition-all",
+												"relative flex items-center gap-4 p-4 rounded-xl transition-all",
 												isAnyIndexing
-													? "bg-primary/5 border-primary/20"
-													: "bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10"
+													? "bg-primary/5 border-0"
+													: "bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10 border border-border"
 											)}
 										>
 											<div
@@ -225,22 +209,17 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 												{isAnyIndexing ? (
 													<p className="text-[11px] text-primary mt-1 flex items-center gap-1.5">
 														<Loader2 className="size-3 animate-spin" />
-														Indexing...
+														Syncing
 													</p>
 												) : (
-													<p className="text-[10px] text-muted-foreground mt-1 whitespace-nowrap">
-														{mostRecentLastIndexed
-															? `Last indexed: ${formatLastIndexedDate(mostRecentLastIndexed)}`
-															: "Never indexed"}
+													<p className="text-[10px] text-muted-foreground mt-1 flex items-center gap-1.5">
+														<span>{formatDocumentCount(documentCount)}</span>
+														<span className="text-muted-foreground/50">•</span>
+														<span>
+															{accountCount} {accountCount === 1 ? "Account" : "Accounts"}
+														</span>
 													</p>
 												)}
-												<p className="text-[10px] text-muted-foreground mt-0.5 flex items-center gap-1.5">
-													<span>{formatDocumentCount(documentCount)}</span>
-													<span className="text-muted-foreground/50">•</span>
-													<span>
-														{accountCount} {accountCount === 1 ? "Account" : "Accounts"}
-													</span>
-												</p>
 											</div>
 											<Button
 												variant="secondary"
@@ -257,22 +236,19 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 								{/* Non-OAuth Connectors - Individual Cards */}
 								{filteredNonOAuthConnectors.map((connector) => {
 									const isIndexing = indexingConnectorIds.has(connector.id);
-									const activeTask = logsSummary?.active_tasks?.find(
-										(task: LogActiveTask) => task.connector_id === connector.id
-									);
 									const documentCount = getDocumentCountForConnector(
 										connector.connector_type,
 										documentTypeCounts
 									);
-
+									const isMCPConnector = connector.connector_type === "MCP_CONNECTOR";
 									return (
 										<div
 											key={`connector-${connector.id}`}
 											className={cn(
-												"flex items-center gap-4 p-4 rounded-xl border border-border transition-all",
+												"flex items-center gap-4 p-4 rounded-xl transition-all",
 												isIndexing
-													? "bg-primary/5 border-primary/20"
-													: "bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10"
+													? "bg-primary/5 border-0"
+													: "bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10 border border-border"
 											)}
 										>
 											<div
@@ -286,29 +262,21 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 												{getConnectorIcon(connector.connector_type, "size-6")}
 											</div>
 											<div className="flex-1 min-w-0">
-												<p className="text-[14px] font-semibold leading-tight truncate">
-													{connector.name}
-												</p>
+												<div className="flex items-center gap-2">
+													<p className="text-[14px] font-semibold leading-tight">
+														{connector.name}
+													</p>
+												</div>
 												{isIndexing ? (
 													<p className="text-[11px] text-primary mt-1 flex items-center gap-1.5">
 														<Loader2 className="size-3 animate-spin" />
-														Indexing...
-														{activeTask?.message && (
-															<span className="text-muted-foreground truncate max-w-[150px]">
-																• {activeTask.message}
-															</span>
-														)}
+														Syncing
 													</p>
-												) : (
-													<p className="text-[10px] text-muted-foreground mt-1 whitespace-nowrap">
-														{connector.last_indexed_at
-															? `Last indexed: ${formatLastIndexedDate(connector.last_indexed_at)}`
-															: "Never indexed"}
+												) : !isMCPConnector ? (
+													<p className="text-[10px] text-muted-foreground mt-1">
+														{formatDocumentCount(documentCount)}
 													</p>
-												)}
-												<p className="text-[10px] text-muted-foreground mt-0.5">
-													{formatDocumentCount(documentCount)}
-												</p>
+												) : null}
 											</div>
 											<Button
 												variant="secondary"
@@ -362,19 +330,12 @@ export const ActiveConnectorsTab: FC<ActiveConnectorsTabProps> = ({
 			) : (
 				<div className="flex flex-col items-center justify-center py-20 text-center">
 					<div className="flex h-16 w-16 items-center justify-center rounded-full bg-muted mb-4">
-						<Cable className="size-8 text-muted-foreground/50" />
+						<Cable className="size-8 text-muted-foreground" />
 					</div>
 					<h4 className="text-lg font-semibold">No active sources</h4>
 					<p className="text-sm text-muted-foreground mt-1 max-w-[280px]">
 						Connect your first service to start searching across all your data.
 					</p>
-					<Button
-						variant="link"
-						className="mt-6 text-primary hover:underline"
-						onClick={() => onTabChange("all")}
-					>
-						Browse available connectors
-					</Button>
 				</div>
 			)}
 		</TabsContent>

surfsense_web/components/assistant-ui/connector-popup/tabs/all-connectors-tab.tsx

@@ -1,10 +1,7 @@
 "use client";
 
-import { Plus } from "lucide-react";
 import type { FC } from "react";
-import { Button } from "@/components/ui/button";
 import type { SearchSourceConnector } from "@/contracts/types/connector.types";
-import type { LogActiveTask, LogSummary } from "@/contracts/types/log.types";
 import { ConnectorCard } from "../components/connector-card";
 import { CRAWLERS, OAUTH_CONNECTORS, OTHER_CONNECTORS } from "../constants/connector-constants";
 import { getDocumentCountForConnector } from "../utils/connector-document-mapping";
@@ -30,7 +27,6 @@ interface AllConnectorsTabProps {
 	allConnectors: SearchSourceConnector[] | undefined;
 	documentTypeCounts?: Record<string, number>;
 	indexingConnectorIds?: Set<number>;
-	logsSummary?: LogSummary;
 	onConnectOAuth: (connector: (typeof OAUTH_CONNECTORS)[number]) => void;
 	onConnectNonOAuth?: (connectorType: string) => void;
 	onCreateWebcrawler?: () => void;
@@ -41,13 +37,11 @@ interface AllConnectorsTabProps {
 
 export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 	searchQuery,
-	searchSpaceId,
 	connectedTypes,
 	connectingId,
 	allConnectors,
 	documentTypeCounts,
 	indexingConnectorIds,
-	logsSummary,
 	onConnectOAuth,
 	onConnectNonOAuth,
 	onCreateWebcrawler,
@@ -55,14 +49,6 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 	onManage,
 	onViewAccountsList,
 }) => {
-	// Helper to find active task for a connector
-	const getActiveTaskForConnector = (connectorId: number): LogActiveTask | undefined => {
-		if (!logsSummary?.active_tasks) return undefined;
-		return logsSummary.active_tasks.find(
-			(task: LogActiveTask) => task.connector_id === connectorId
-		);
-	};
-
 	// Filter connectors based on search
 	const filteredOAuth = OAUTH_CONNECTORS.filter(
 		(c) =>
@@ -103,6 +89,8 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 										)
 									: [];
 
+							const accountCount = typeConnectors.length;
+
 							// Get the most recent last_indexed_at across all accounts
 							const mostRecentLastIndexed = typeConnectors.reduce<string | undefined>(
 								(latest, c) => {
@@ -123,11 +111,6 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 							// Check if any account is currently indexing
 							const isIndexing = typeConnectors.some((c) => indexingConnectorIds?.has(c.id));
 
-							// Get active task from any indexing account
-							const activeTask = typeConnectors
-								.map((c) => getActiveTaskForConnector(c.id))
-								.find((task) => task !== undefined);
-
 							return (
 								<ConnectorCard
 									key={connector.id}
@@ -138,10 +121,9 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 									isConnected={isConnected}
 									isConnecting={isConnecting}
 									documentCount={documentCount}
-									accountCount={typeConnectors.length}
-									lastIndexedAt={mostRecentLastIndexed}
+									accountCount={accountCount}
+
 									isIndexing={isIndexing}
-									activeTask={activeTask}
 									onConnect={() => onConnectOAuth(connector)}
 									onManage={
 										isConnected && onViewAccountsList
@@ -179,9 +161,6 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 								documentTypeCounts
 							);
 							const isIndexing = actualConnector && indexingConnectorIds?.has(actualConnector.id);
-							const activeTask = actualConnector
-								? getActiveTaskForConnector(actualConnector.id)
-								: undefined;
 
 							const handleConnect = onConnectNonOAuth
 								? () => onConnectNonOAuth(connector.connectorType)
@@ -197,9 +176,8 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 									isConnected={isConnected}
 									isConnecting={isConnecting}
 									documentCount={documentCount}
-									lastIndexedAt={actualConnector?.last_indexed_at}
+
 									isIndexing={isIndexing}
-									activeTask={activeTask}
 									onConnect={handleConnect}
 									onManage={
 										actualConnector && onManage ? () => onManage(actualConnector) : undefined
@@ -240,9 +218,6 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 								? getDocumentCountForConnector(crawler.connectorType, documentTypeCounts)
 								: undefined;
 							const isIndexing = actualConnector && indexingConnectorIds?.has(actualConnector.id);
-							const activeTask = actualConnector
-								? getActiveTaskForConnector(actualConnector.id)
-								: undefined;
 
 							const handleConnect =
 								isYouTube && onCreateYouTubeCrawler
@@ -267,9 +242,7 @@ export const AllConnectorsTab: FC<AllConnectorsTabProps> = ({
 									isConnected={isConnected}
 									isConnecting={isConnecting}
 									documentCount={documentCount}
-									lastIndexedAt={actualConnector?.last_indexed_at}
 									isIndexing={isIndexing}
-									activeTask={activeTask}
 									onConnect={handleConnect}
 									onManage={
 										actualConnector && onManage ? () => onManage(actualConnector) : undefined

surfsense_web/components/assistant-ui/connector-popup/utils/mcp-config-validator.ts

@@ -0,0 +1,254 @@
+/**
+ * MCP Configuration Validator Utility
+ * 
+ * Shared validation and parsing logic for MCP (Model Context Protocol) server configurations.
+ * 
+ * Features:
+ * - Zod schema validation for runtime type safety
+ * - Configuration caching to avoid repeated parsing (5-minute TTL)
+ * - Standardized error messages
+ * - Connection testing utilities
+ * 
+ * Usage:
+ * ```typescript
+ * // Parse and validate config
+ * const result = parseMCPConfig(jsonString);
+ * if (result.config) {
+ *   // Valid config
+ * } else {
+ *   // Show result.error to user
+ * }
+ * 
+ * // Test connection
+ * const testResult = await testMCPConnection(config);
+ * if (testResult.status === "success") {
+ *   console.log(`Found ${testResult.tools.length} tools`);
+ * }
+ * ```
+ * 
+ * @module mcp-config-validator
+ */
+
+import { z } from "zod";
+import type { MCPServerConfig, MCPToolDefinition } from "@/contracts/types/mcp.types";
+import { connectorsApiService } from "@/lib/apis/connectors-api.service";
+
+/**
+ * Zod schema for MCP server configuration
+ * Provides compile-time and runtime type safety
+ * 
+ * Exported for advanced use cases (e.g., form builders)
+ */
+export const MCPServerConfigSchema = z.object({
+	name: z.string().optional(),
+	command: z
+		.string({ required_error: "Command field is required" })
+		.min(1, "Command cannot be empty"),
+	args: z.array(z.string()).optional().default([]),
+	env: z.record(z.string(), z.string()).optional().default({}),
+	transport: z.enum(["stdio", "sse"]).optional().default("stdio"),
+});
+
+/**
+ * Shared MCP configuration validation result
+ */
+export interface MCPConfigValidationResult {
+	config: MCPServerConfig | null;
+	error: string | null;
+}
+
+/**
+ * Shared MCP connection test result
+ */
+export interface MCPConnectionTestResult {
+	status: "success" | "error";
+	message: string;
+	tools: MCPToolDefinition[];
+}
+
+/**
+ * Cache for parsed configurations to avoid re-parsing
+ * Key: JSON string, Value: { config, timestamp }
+ */
+const configCache = new Map<string, { config: MCPServerConfig; timestamp: number }>();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Clear expired entries from config cache
+ */
+const clearExpiredCache = () => {
+	const now = Date.now();
+	for (const [key, value] of configCache.entries()) {
+		if (now - value.timestamp > CACHE_TTL) {
+			configCache.delete(key);
+		}
+	}
+};
+
+/**
+ * Parse and validate MCP server configuration from JSON string
+ * Uses Zod for schema validation and caching to avoid re-parsing
+ * @param configJson - JSON string containing MCP server configuration
+ * @returns Validation result with parsed config or error message
+ */
+export const parseMCPConfig = (configJson: string): MCPConfigValidationResult => {
+	// Check cache first
+	const cached = configCache.get(configJson);
+	if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+		console.log('[MCP Validator] ✅ Using cached config');
+		return { config: cached.config, error: null };
+	}
+
+	console.log('[MCP Validator] 🔍 Parsing new config...');
+
+	// Clean up expired cache entries periodically
+	if (configCache.size > 100) {
+		clearExpiredCache();
+	}
+
+	try {
+		const parsed = JSON.parse(configJson);
+
+		// Validate that it's an object, not an array
+		if (Array.isArray(parsed)) {
+			console.error('[MCP Validator] ❌ Error: Config is an array, expected object');
+			return {
+				config: null,
+				error: "Please provide a single server configuration object, not an array",
+			};
+		}
+
+		// Use Zod schema validation for robust type checking
+		const result = MCPServerConfigSchema.safeParse(parsed);
+
+		if (!result.success) {
+			// Format Zod validation errors for user-friendly display
+			const firstError = result.error.issues[0];
+			const fieldPath = firstError.path.join(".");
+			
+			// Clean up error message - remove technical Zod jargon
+			let errorMsg = firstError.message;
+			
+			// Replace technical error messages with user-friendly ones
+			if (errorMsg.includes("expected string, received undefined")) {
+				errorMsg = "This field is required";
+			} else if (errorMsg.includes("Invalid input")) {
+				errorMsg = "Invalid value";
+			}
+			
+			const formattedError = fieldPath ? `${fieldPath}: ${errorMsg}` : errorMsg;
+			
+			console.error('[MCP Validator] ❌ Validation error:', formattedError);
+			console.error('[MCP Validator] Full Zod errors:', result.error.issues);
+			
+			return {
+				config: null,
+				error: formattedError,
+			};
+		}
+
+		const config: MCPServerConfig = {
+			command: result.data.command,
+			args: result.data.args,
+			env: result.data.env,
+			transport: result.data.transport,
+		};
+
+		// Cache the successfully parsed config
+		configCache.set(configJson, {
+			config,
+			timestamp: Date.now(),
+		});
+		
+		console.log('[MCP Validator] ✅ Config parsed successfully:', config);
+
+		return {
+			config,
+			error: null,
+		};
+	} catch (error) {
+		const errorMsg = error instanceof Error ? error.message : "Invalid JSON";
+		console.error('[MCP Validator] ❌ JSON parse error:', errorMsg);
+		return {
+			config: null,
+			error: errorMsg,
+		};
+	}
+};
+
+/**
+ * Test connection to MCP server
+ * @param serverConfig - MCP server configuration to test
+ * @returns Connection test result with status, message, and available tools
+ */
+export const testMCPConnection = async (
+	serverConfig: MCPServerConfig
+): Promise<MCPConnectionTestResult> => {
+	try {
+		const result = await connectorsApiService.testMCPConnection(serverConfig);
+
+		if (result.status === "success") {
+			return {
+				status: "success",
+				message: `Successfully connected. Found ${result.tools.length} tool${result.tools.length !== 1 ? "s" : ""}.`,
+				tools: result.tools,
+			};
+		}
+
+		return {
+			status: "error",
+			message: result.message || "Failed to connect",
+			tools: [],
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			message: error instanceof Error ? error.message : "Failed to connect",
+			tools: [],
+		};
+	}
+};
+
+/**
+ * Extract server name from MCP config JSON with caching
+ * @param configJson - JSON string containing MCP server configuration
+ * @returns Server name if found, otherwise default name
+ */
+export const extractServerName = (configJson: string): string => {
+	try {
+		const parsed = JSON.parse(configJson);
+		
+		// Use Zod to validate and extract name field safely
+		const nameSchema = z.object({ name: z.string().optional() });
+		const result = nameSchema.safeParse(parsed);
+		
+		if (result.success && result.data.name) {
+			return result.data.name;
+		}
+	} catch {
+		// Return default if parsing fails
+	}
+	return "MCP Server";
+};
+
+/**
+ * Clear the configuration cache
+ * Useful for testing or when memory management is needed
+ */
+export const clearConfigCache = () => {
+	configCache.clear();
+};
+
+/**
+ * Get cache statistics for monitoring/debugging
+ */
+export const getConfigCacheStats = () => {
+	return {
+		size: configCache.size,
+		entries: Array.from(configCache.entries()).map(([key, value]) => ({
+			configPreview: key.substring(0, 50) + (key.length > 50 ? "..." : ""),
+			timestamp: new Date(value.timestamp).toISOString(),
+			age: Date.now() - value.timestamp,
+		})),
+	};
+};

surfsense_web/components/assistant-ui/connector-popup/views/connector-accounts-list-view.tsx

@@ -6,7 +6,6 @@ import type { FC } from "react";
 import { Button } from "@/components/ui/button";
 import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
 import type { SearchSourceConnector } from "@/contracts/types/connector.types";
-import type { LogActiveTask, LogSummary } from "@/contracts/types/log.types";
 import { cn } from "@/lib/utils";
 import { useConnectorStatus } from "../hooks/use-connector-status";
 import { getConnectorDisplayName } from "../tabs/all-connectors-tab";
@@ -16,13 +15,20 @@ interface ConnectorAccountsListViewProps {
 	connectorTitle: string;
 	connectors: SearchSourceConnector[];
 	indexingConnectorIds: Set<number>;
-	logsSummary: LogSummary | undefined;
 	onBack: () => void;
 	onManage: (connector: SearchSourceConnector) => void;
 	onAddAccount: () => void;
 	isConnecting?: boolean;
 }
 
+/**
+ * Check if a connector type is indexable
+ */
+function isIndexableConnector(connectorType: string): boolean {
+	const nonIndexableTypes = ["MCP_CONNECTOR"];
+	return !nonIndexableTypes.includes(connectorType);
+}
+
 /**
  * Format last indexed date with contextual messages
  */
@@ -60,7 +66,6 @@ export const ConnectorAccountsListView: FC<ConnectorAccountsListViewProps> = ({
 	connectorTitle,
 	connectors,
 	indexingConnectorIds,
-	logsSummary,
 	onBack,
 	onManage,
 	onAddAccount,
@@ -125,7 +130,7 @@ export const ConnectorAccountsListView: FC<ConnectorAccountsListViewProps> = ({
 							)}
 						</div>
 						<span className="text-[11px] sm:text-[12px] font-medium">
-							{isConnecting ? "Connecting..." : "Add Account"}
+							{isConnecting ? "Connecting" : "Add Account"}
 						</span>
 					</button>
 				</div>
@@ -137,18 +142,15 @@ export const ConnectorAccountsListView: FC<ConnectorAccountsListViewProps> = ({
 				<div className="grid grid-cols-1 sm:grid-cols-2 gap-3">
 					{typeConnectors.map((connector) => {
 						const isIndexing = indexingConnectorIds.has(connector.id);
-						const activeTask = logsSummary?.active_tasks?.find(
-							(task: LogActiveTask) => task.connector_id === connector.id
-						);
 
 						return (
 							<div
 								key={connector.id}
 								className={cn(
-									"flex items-center gap-4 p-4 rounded-xl border border-border transition-all",
+									"flex items-center gap-4 p-4 rounded-xl transition-all",
 									isIndexing
-										? "bg-primary/5 border-primary/20"
-										: "bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10"
+										? "bg-primary/5 border-0"
+										: "bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10 border border-border"
 								)}
 							>
 								<div
@@ -168,18 +170,15 @@ export const ConnectorAccountsListView: FC<ConnectorAccountsListViewProps> = ({
 									{isIndexing ? (
 										<p className="text-[11px] text-primary mt-1 flex items-center gap-1.5">
 											<Loader2 className="size-3 animate-spin" />
-											Indexing...
-											{activeTask?.message && (
-												<span className="text-muted-foreground truncate max-w-[100px]">
-													• {activeTask.message}
-												</span>
-											)}
+											Syncing
 										</p>
 									) : (
 										<p className="text-[10px] text-muted-foreground mt-1 whitespace-nowrap truncate">
-											{connector.last_indexed_at
-												? `Last indexed: ${formatLastIndexedDate(connector.last_indexed_at)}`
-												: "Never indexed"}
+											{isIndexableConnector(connector.connector_type)
+												? connector.last_indexed_at
+													? `Last indexed: ${formatLastIndexedDate(connector.last_indexed_at)}`
+													: "Never indexed"
+												: "Active"}
 										</p>
 									)}
 								</div>

surfsense_web/components/assistant-ui/connector-popup/views/mcp-connector-list-view.tsx

@@ -0,0 +1,145 @@
+"use client";
+
+import { Plus, Server, XCircle } from "lucide-react";
+import type { FC } from "react";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Button } from "@/components/ui/button";
+import { EnumConnectorName } from "@/contracts/enums/connector";
+import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
+import type { SearchSourceConnector } from "@/contracts/types/connector.types";
+import { cn } from "@/lib/utils";
+
+interface MCPConnectorListViewProps {
+	mcpConnectors: SearchSourceConnector[];
+	onAddNew: () => void;
+	onManageConnector: (connector: SearchSourceConnector) => void;
+	onBack: () => void;
+}
+
+export const MCPConnectorListView: FC<MCPConnectorListViewProps> = ({
+	mcpConnectors,
+	onAddNew,
+	onManageConnector,
+	onBack,
+}) => {
+	// Validate that all connectors are MCP connectors
+	const invalidConnectors = mcpConnectors.filter(
+		(c) => c.connector_type !== EnumConnectorName.MCP_CONNECTOR
+	);
+
+	if (invalidConnectors.length > 0) {
+		console.error(
+			"MCPConnectorListView received non-MCP connectors:",
+			invalidConnectors.map((c) => c.connector_type)
+		);
+		return (
+			<Alert className="border-red-500/50 bg-red-500/10">
+				<XCircle className="h-4 w-4 text-red-600" />
+				<AlertTitle>Invalid Connector Type</AlertTitle>
+				<AlertDescription>
+					This view can only display MCP connectors. Found {invalidConnectors.length} invalid
+					connector(s).
+				</AlertDescription>
+			</Alert>
+		);
+	}
+	return (
+		<div className="flex flex-col h-full">
+			{/* Header */}
+			<div className="flex items-center justify-between mb-6 shrink-0">
+				<div className="flex items-center gap-3">
+					<Button
+						variant="ghost"
+						size="icon"
+						onClick={onBack}
+						className="h-8 w-8"
+					>
+						<svg
+							xmlns="http://www.w3.org/2000/svg"
+							width="16"
+							height="16"
+							viewBox="0 0 24 24"
+							fill="none"
+							stroke="currentColor"
+							strokeWidth="2"
+							strokeLinecap="round"
+							strokeLinejoin="round"
+						>
+							<path d="m15 18-6-6 6-6" />
+						</svg>
+					</Button>
+					<div>
+						<h2 className="text-lg sm:text-xl font-semibold">MCP Connectors</h2>
+						<p className="text-xs sm:text-sm text-muted-foreground">
+							Manage your Model Context Protocol servers
+						</p>
+					</div>
+				</div>
+			</div>
+
+			{/* Add New Button */}
+			<div className="mb-4 shrink-0">
+				<Button
+					onClick={onAddNew}
+					className="w-full"
+					variant="outline"
+				>
+					<Plus className="h-4 w-4 mr-2" />
+					Add New MCP Server
+				</Button>
+			</div>
+
+			{/* MCP Connectors List */}
+			<div className="space-y-3 flex-1 overflow-y-auto">
+				{mcpConnectors.length === 0 ? (
+					<div className="flex flex-col items-center justify-center py-12 text-center">
+						<div className="h-16 w-16 rounded-full bg-slate-400/5 dark:bg-white/5 flex items-center justify-center mb-4">
+							<Server className="h-8 w-8 text-muted-foreground" />
+						</div>
+						<h3 className="text-sm font-medium mb-1">No MCP Servers</h3>
+						<p className="text-xs text-muted-foreground max-w-[280px]">
+							Get started by adding your first Model Context Protocol server
+						</p>
+					</div>
+				) : (
+					mcpConnectors.map((connector) => {
+						// Extract server name from config
+						const serverName = connector.config?.server_config?.name || connector.name;
+						
+						return (
+							<div
+								key={connector.id}
+								className={cn(
+									"flex items-center gap-4 p-4 rounded-xl border border-border transition-all",
+									"bg-slate-400/5 dark:bg-white/5 hover:bg-slate-400/10 dark:hover:bg-white/10"
+								)}
+							>
+								<div
+									className={cn(
+										"flex h-12 w-12 items-center justify-center rounded-lg border shrink-0",
+										"bg-slate-400/5 dark:bg-white/5 border-slate-400/5 dark:border-white/5"
+									)}
+								>
+									{getConnectorIcon("MCP_CONNECTOR", "size-6")}
+								</div>
+								<div className="flex-1 min-w-0">
+									<p className="text-[14px] font-semibold leading-tight truncate">
+										{serverName}
+									</p>
+								</div>
+								<Button
+									variant="secondary"
+									size="sm"
+									className="h-8 text-[11px] px-3 rounded-lg font-medium bg-white text-slate-700 hover:bg-slate-50 border-0 shadow-xs dark:bg-secondary dark:text-secondary-foreground dark:hover:bg-secondary/80 shrink-0"
+									onClick={() => onManageConnector(connector)}
+								>
+									Manage
+								</Button>
+							</div>
+						);
+					})
+				)}
+			</div>
+		</div>
+	);
+};

surfsense_web/components/assistant-ui/document-upload-popup.tsx

@@ -2,7 +2,6 @@
 
 import { useAtomValue } from "jotai";
 import { Upload } from "lucide-react";
-import { useRouter } from "next/navigation";
 import {
 	createContext,
 	type FC,
@@ -85,13 +84,11 @@ const DocumentUploadPopupContent: FC<{
 	onOpenChange: (open: boolean) => void;
 }> = ({ isOpen, onOpenChange }) => {
 	const searchSpaceId = useAtomValue(activeSearchSpaceIdAtom);
-	const router = useRouter();
 
 	if (!searchSpaceId) return null;
 
 	const handleSuccess = () => {
 		onOpenChange(false);
-		router.push(`/dashboard/${searchSpaceId}/documents`);
 	};
 
 	return (

surfsense_web/components/assistant-ui/inline-mention-editor.tsx

@@ -12,6 +12,7 @@ import {
 } from "react";
 import ReactDOMServer from "react-dom/server";
 import type { Document } from "@/contracts/types/document.types";
+import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
 import { cn } from "@/lib/utils";
 
 export interface MentionedDocument {
@@ -166,12 +167,19 @@ export const InlineMentionEditor = forwardRef<InlineMentionEditorRef, InlineMent
 				chip.setAttribute(CHIP_DOCTYPE_ATTR, doc.document_type ?? "UNKNOWN");
 				chip.contentEditable = "false";
 				chip.className =
-					"inline-flex items-center gap-0.5 mx-0.5 pl-1 pr-0.5 py-0.5 rounded bg-primary/10 text-xs font-bold text-primary border border-primary/10 select-none";
+					"inline-flex items-center gap-1 mx-0.5 pl-1 pr-0.5 py-0.5 rounded bg-primary/10 text-xs font-bold text-primary/60 select-none";
 				chip.style.userSelect = "none";
 				chip.style.verticalAlign = "baseline";
 
+				// Add document type icon
+				const iconSpan = document.createElement("span");
+				iconSpan.className = "shrink-0 flex items-center text-muted-foreground";
+				iconSpan.innerHTML = ReactDOMServer.renderToString(
+					getConnectorIcon(doc.document_type ?? "UNKNOWN", "h-3 w-3")
+				);
+
 				const titleSpan = document.createElement("span");
-				titleSpan.className = "max-w-[80px] truncate";
+				titleSpan.className = "max-w-[120px] truncate";
 				titleSpan.textContent = doc.title;
 				titleSpan.title = doc.title;
 
@@ -197,6 +205,7 @@ export const InlineMentionEditor = forwardRef<InlineMentionEditorRef, InlineMent
 					focusAtEnd();
 				};
 
+				chip.appendChild(iconSpan);
 				chip.appendChild(titleSpan);
 				chip.appendChild(removeBtn);
 

surfsense_web/components/assistant-ui/thread-welcome.tsx

@@ -1,71 +0,0 @@
-import { useAtomValue } from "jotai";
-import type { FC } from "react";
-import { useMemo } from "react";
-import { currentUserAtom } from "@/atoms/user/user-query.atoms";
-import { Composer } from "@/components/assistant-ui/composer";
-
-const getTimeBasedGreeting = (userEmail?: string): string => {
-	const hour = new Date().getHours();
-
-	// Extract first name from email if available
-	const firstName = userEmail
-		? userEmail.split("@")[0].split(".")[0].charAt(0).toUpperCase() +
-			userEmail.split("@")[0].split(".")[0].slice(1)
-		: null;
-
-	// Array of greeting variations for each time period
-	const morningGreetings = ["Good morning", "Fresh start today", "Morning", "Hey there"];
-
-	const afternoonGreetings = ["Good afternoon", "Afternoon", "Hey there", "Hi there"];
-
-	const eveningGreetings = ["Good evening", "Evening", "Hey there", "Hi there"];
-
-	const nightGreetings = ["Good night", "Evening", "Hey there", "Winding down"];
-
-	const lateNightGreetings = ["Still up", "Night owl mode", "Up past bedtime", "Hi there"];
-
-	// Select a random greeting based on time
-	let greeting: string;
-	if (hour < 5) {
-		// Late night: midnight to 5 AM
-		greeting = lateNightGreetings[Math.floor(Math.random() * lateNightGreetings.length)];
-	} else if (hour < 12) {
-		greeting = morningGreetings[Math.floor(Math.random() * morningGreetings.length)];
-	} else if (hour < 18) {
-		greeting = afternoonGreetings[Math.floor(Math.random() * afternoonGreetings.length)];
-	} else if (hour < 22) {
-		greeting = eveningGreetings[Math.floor(Math.random() * eveningGreetings.length)];
-	} else {
-		// Night: 10 PM to midnight
-		greeting = nightGreetings[Math.floor(Math.random() * nightGreetings.length)];
-	}
-
-	// Add personalization with first name if available
-	if (firstName) {
-		return `${greeting}, ${firstName}!`;
-	}
-
-	return `${greeting}!`;
-};
-
-export const ThreadWelcome: FC = () => {
-	const { data: user } = useAtomValue(currentUserAtom);
-
-	// Memoize greeting so it doesn't change on re-renders (only on user change)
-	const greeting = useMemo(() => getTimeBasedGreeting(user?.email), [user?.email]);
-
-	return (
-		<div className="aui-thread-welcome-root mx-auto flex w-full max-w-(--thread-max-width) grow flex-col items-center px-4 relative">
-			{/* Greeting positioned above the composer - fixed position */}
-			<div className="aui-thread-welcome-message absolute bottom-[calc(50%+5rem)] left-0 right-0 flex flex-col items-center text-center">
-				<h1 className="aui-thread-welcome-message-inner fade-in slide-in-from-bottom-2 animate-in text-3xl md:text-5xl delay-100 duration-500 ease-out fill-mode-both">
-					{greeting}
-				</h1>
-			</div>
-			{/* Composer - top edge fixed, expands downward only */}
-			<div className="fade-in slide-in-from-bottom-3 animate-in delay-200 duration-500 ease-out fill-mode-both w-full flex items-start justify-center absolute top-[calc(50%-3.5rem)] left-0 right-0">
-				<Composer />
-			</div>
-		</div>
-	);
-};

surfsense_web/components/assistant-ui/thread.tsx

@@ -132,14 +132,23 @@ const ThreadScrollToBottom: FC = () => {
 	);
 };
 
-const getTimeBasedGreeting = (userEmail?: string): string => {
+const getTimeBasedGreeting = (user?: { display_name?: string | null; email?: string }): string => {
 	const hour = new Date().getHours();
 
-	// Extract first name from email if available
-	const firstName = userEmail
-		? userEmail.split("@")[0].split(".")[0].charAt(0).toUpperCase() +
-			userEmail.split("@")[0].split(".")[0].slice(1)
-		: null;
+	// Extract first name: prefer display_name, fall back to email extraction
+	let firstName: string | null = null;
+
+	if (user?.display_name?.trim()) {
+		// Use display_name if available and not empty
+		// Extract first name from display_name (take first word)
+		const nameParts = user.display_name.trim().split(/\s+/);
+		firstName = nameParts[0].charAt(0).toUpperCase() + nameParts[0].slice(1).toLowerCase();
+	} else if (user?.email) {
+		// Fall back to email extraction if display_name is not available
+		firstName =
+			user.email.split("@")[0].split(".")[0].charAt(0).toUpperCase() +
+			user.email.split("@")[0].split(".")[0].slice(1);
+	}
 
 	// Array of greeting variations for each time period
 	const morningGreetings = ["Good morning", "Fresh start today", "Morning", "Hey there"];
@@ -180,7 +189,7 @@ const ThreadWelcome: FC = () => {
 	const { data: user } = useAtomValue(currentUserAtom);
 
 	// Memoize greeting so it doesn't change on re-renders (only on user change)
-	const greeting = useMemo(() => getTimeBasedGreeting(user?.email), [user?.email]);
+	const greeting = useMemo(() => getTimeBasedGreeting(user), [user]);
 
 	return (
 		<div className="aui-thread-welcome-root mx-auto flex w-full max-w-(--thread-max-width) grow flex-col items-center px-4 relative">
@@ -199,7 +208,7 @@ const ThreadWelcome: FC = () => {
 };
 
 const Composer: FC = () => {
-	// ---- State for document mentions (using atoms to persist across remounts) ----
+	// Document mention state (atoms persist across component remounts)
 	const [mentionedDocuments, setMentionedDocuments] = useAtom(mentionedDocumentsAtom);
 	const [showDocumentPopover, setShowDocumentPopover] = useState(false);
 	const [mentionQuery, setMentionQuery] = useState("");
@@ -211,16 +220,12 @@ const Composer: FC = () => {
 	const composerRuntime = useComposerRuntime();
 	const hasAutoFocusedRef = useRef(false);
 
-	// Check if thread is empty (new chat)
 	const isThreadEmpty = useAssistantState(({ thread }) => thread.isEmpty);
-
-	// Check if thread is currently running (streaming response)
 	const isThreadRunning = useAssistantState(({ thread }) => thread.isRunning);
 
-	// Auto-focus editor when on new chat page
+	// Auto-focus editor on new chat page after mount
 	useEffect(() => {
 		if (isThreadEmpty && !hasAutoFocusedRef.current && editorRef.current) {
-			// Small delay to ensure the editor is fully mounted
 			const timeoutId = setTimeout(() => {
 				editorRef.current?.focus();
 				hasAutoFocusedRef.current = true;
@@ -229,7 +234,7 @@ const Composer: FC = () => {
 		}
 	}, [isThreadEmpty]);
 
-	// Sync mentioned document IDs to atom for use in chat request
+	// Sync mentioned document IDs to atom for inclusion in chat request payload
 	useEffect(() => {
 		setMentionedDocumentIds({
 			surfsense_doc_ids: mentionedDocuments
@@ -241,7 +246,7 @@ const Composer: FC = () => {
 		});
 	}, [mentionedDocuments, setMentionedDocumentIds]);
 
-	// Handle text change from inline editor - sync with assistant-ui composer
+	// Sync editor text with assistant-ui composer runtime
 	const handleEditorChange = useCallback(
 		(text: string) => {
 			composerRuntime.setText(text);
@@ -249,13 +254,13 @@ const Composer: FC = () => {
 		[composerRuntime]
 	);
 
-	// Handle @ mention trigger from inline editor
+	// Open document picker when @ mention is triggered
 	const handleMentionTrigger = useCallback((query: string) => {
 		setShowDocumentPopover(true);
 		setMentionQuery(query);
 	}, []);
 
-	// Handle mention close
+	// Close document picker and reset query
 	const handleMentionClose = useCallback(() => {
 		if (showDocumentPopover) {
 			setShowDocumentPopover(false);
@@ -263,7 +268,7 @@ const Composer: FC = () => {
 		}
 	}, [showDocumentPopover]);
 
-	// Handle keyboard navigation when popover is open
+	// Keyboard navigation for document picker (arrow keys, Enter, Escape)
 	const handleKeyDown = useCallback(
 		(e: React.KeyboardEvent) => {
 			if (showDocumentPopover) {
@@ -293,15 +298,13 @@ const Composer: FC = () => {
 		[showDocumentPopover]
 	);
 
-	// Handle submit from inline editor (Enter key)
+	// Submit message (blocked during streaming or when document picker is open)
 	const handleSubmit = useCallback(() => {
-		// Prevent sending while a response is still streaming
 		if (isThreadRunning) {
 			return;
 		}
 		if (!showDocumentPopover) {
 			composerRuntime.send();
-			// Clear the editor after sending
 			editorRef.current?.clear();
 			setMentionedDocuments([]);
 			setMentionedDocumentIds({
@@ -317,6 +320,7 @@ const Composer: FC = () => {
 		setMentionedDocumentIds,
 	]);
 
+	// Remove document from mentions and sync IDs to atom
 	const handleDocumentRemove = useCallback(
 		(docId: number, docType?: string) => {
 			setMentionedDocuments((prev) => {
@@ -335,6 +339,7 @@ const Composer: FC = () => {
 		[setMentionedDocuments, setMentionedDocumentIds]
 	);
 
+	// Add selected documents from picker, insert chips, and sync IDs to atom
 	const handleDocumentsMention = useCallback(
 		(documents: Pick<Document, "id" | "title" | "document_type">[]) => {
 			const existingKeys = new Set(mentionedDocuments.map((d) => `${d.document_type}:${d.id}`));
@@ -372,7 +377,7 @@ const Composer: FC = () => {
 		<ComposerPrimitive.Root className="aui-composer-root relative flex w-full flex-col">
 			<ComposerPrimitive.AttachmentDropzone className="aui-composer-attachment-dropzone flex w-full flex-col rounded-2xl border-input bg-muted px-1 pt-2 outline-none transition-shadow data-[dragging=true]:border-ring data-[dragging=true]:border-dashed data-[dragging=true]:bg-accent/50">
 				<ComposerAttachments />
-				{/* -------- Inline Mention Editor -------- */}
+				{/* Inline editor with @mention support */}
 				<div ref={editorContainerRef} className="aui-composer-input-wrapper px-3 pt-3 pb-6">
 					<InlineMentionEditor
 						ref={editorRef}
@@ -387,45 +392,29 @@ const Composer: FC = () => {
 					/>
 				</div>
 
-				{/* -------- Document mention popover (rendered via portal) -------- */}
+				{/* Document picker popover (portal to body for proper z-index stacking) */}
 				{showDocumentPopover &&
 					typeof document !== "undefined" &&
 					createPortal(
-						<>
-							{/* Backdrop */}
-							<button
-								type="button"
-								className="fixed inset-0 cursor-default"
-								style={{ zIndex: 9998 }}
-								onClick={() => setShowDocumentPopover(false)}
-								aria-label="Close document picker"
-							/>
-							{/* Popover positioned above input */}
-							<div
-								className="fixed shadow-2xl rounded-lg border border-border overflow-hidden bg-popover"
-								style={{
-									zIndex: 9999,
-									bottom: editorContainerRef.current
-										? `${window.innerHeight - editorContainerRef.current.getBoundingClientRect().top + 8}px`
-										: "200px",
-									left: editorContainerRef.current
-										? `${editorContainerRef.current.getBoundingClientRect().left}px`
-										: "50%",
-								}}
-							>
-								<DocumentMentionPicker
-									ref={documentPickerRef}
-									searchSpaceId={Number(search_space_id)}
-									onSelectionChange={handleDocumentsMention}
-									onDone={() => {
-										setShowDocumentPopover(false);
-										setMentionQuery("");
-									}}
-									initialSelectedDocuments={mentionedDocuments}
-									externalSearch={mentionQuery}
-								/>
-							</div>
-						</>,
+						<DocumentMentionPicker
+							ref={documentPickerRef}
+							searchSpaceId={Number(search_space_id)}
+							onSelectionChange={handleDocumentsMention}
+							onDone={() => {
+								setShowDocumentPopover(false);
+								setMentionQuery("");
+							}}
+							initialSelectedDocuments={mentionedDocuments}
+							externalSearch={mentionQuery}
+							containerStyle={{
+								bottom: editorContainerRef.current
+									? `${window.innerHeight - editorContainerRef.current.getBoundingClientRect().top + 8}px`
+									: "200px",
+								left: editorContainerRef.current
+									? `${editorContainerRef.current.getBoundingClientRect().left}px`
+									: "50%",
+							}}
+						/>,
 						document.body
 					)}
 				<ComposerAction />

surfsense_web/components/assistant-ui/tooltip-icon-button.tsx

@@ -27,12 +27,7 @@ export const TooltipIconButton = forwardRef<HTMLButtonElement, TooltipIconButton
 						<span className="aui-sr-only sr-only">{tooltip}</span>
 					</Button>
 				</TooltipTrigger>
-				<TooltipContent
-					side={side}
-					className="bg-black text-white font-medium shadow-xl px-3 py-1.5 dark:bg-zinc-800 dark:text-zinc-50 border-none"
-				>
-					{tooltip}
-				</TooltipContent>
+				<TooltipContent side={side}>{tooltip}</TooltipContent>
 			</Tooltip>
 		);
 	}

surfsense_web/components/connectors/google-drive-folder-tree.tsx

@@ -5,13 +5,13 @@ import {
 	ChevronRight,
 	File,
 	FileText,
-	Folder,
+	FolderClosed,
 	FolderOpen,
 	HardDrive,
 	Image,
 	Loader2,
 	Presentation,
-	Sheet,
+	FileSpreadsheet,
 } from "lucide-react";
 import { useState } from "react";
 import { Checkbox } from "@/components/ui/checkbox";
@@ -53,16 +53,16 @@ interface GoogleDriveFolderTreeProps {
 // Helper to get appropriate icon for file type
 function getFileIcon(mimeType: string, className: string = "h-4 w-4") {
 	if (mimeType.includes("spreadsheet") || mimeType.includes("excel")) {
-		return <Sheet className={`${className} text-green-600`} />;
+		return <FileSpreadsheet className={`${className} text-green-500`} />;
 	}
 	if (mimeType.includes("presentation") || mimeType.includes("powerpoint")) {
-		return <Presentation className={`${className} text-orange-600`} />;
+		return <Presentation className={`${className} text-orange-500`} />;
 	}
 	if (mimeType.includes("document") || mimeType.includes("word") || mimeType.includes("text")) {
-		return <FileText className={`${className} text-blue-600`} />;
+		return <FileText className={`${className} text-gray-500`} />;
 	}
 	if (mimeType.includes("image")) {
-		return <Image className={`${className} text-purple-600`} />;
+		return <Image className={`${className} text-purple-500`} />;
 	}
 	return <File className={`${className} text-gray-500`} />;
 }
@@ -280,9 +280,9 @@ export function GoogleDriveFolderTree({
 					<div className="shrink-0">
 						{isFolder ? (
 							isExpanded ? (
-								<FolderOpen className="h-3 w-3 sm:h-4 sm:w-4 text-blue-500" />
+								<FolderOpen className="h-3 w-3 sm:h-4 sm:w-4 text-gray-500" />
 							) : (
-								<Folder className="h-3 w-3 sm:h-4 sm:w-4 text-gray-500" />
+								<FolderClosed className="h-3 w-3 sm:h-4 sm:w-4 text-gray-500" />
 							)
 						) : (
 							getFileIcon(item.mimeType, "h-3 w-3 sm:h-4 sm:w-4")

surfsense_web/components/homepage/hero-section.tsx

@@ -184,7 +184,7 @@ function GetStartedButton() {
 	return (
 		<motion.div whileHover={{ scale: 1.02, y: -2 }} whileTap={{ scale: 0.98 }}>
 			<Link
-				href="/login"
+				href="/register"
 				className="group relative z-20 flex h-11 w-full cursor-pointer items-center justify-center gap-2 rounded-xl bg-black px-6 py-2.5 text-sm font-semibold text-white shadow-lg transition-shadow duration-300 hover:shadow-xl sm:w-56 dark:bg-white dark:text-black"
 			>
 				Get Started

surfsense_web/components/layout/providers/LayoutDataProvider.tsx

@@ -21,6 +21,7 @@ import {
 } from "@/components/ui/dialog";
 import { searchSpacesApiService } from "@/lib/apis/search-spaces-api.service";
 import { deleteThread, fetchThreads } from "@/lib/chat/thread-persistence";
+import { cleanupElectric } from "@/lib/electric/client";
 import { resetUser, trackLogout } from "@/lib/posthog/events";
 import { cacheKeys } from "@/lib/query-client/cache-keys";
 import type { ChatItem, NavItem, SearchSpace } from "../types/layout.types";
@@ -278,10 +279,19 @@ export function LayoutDataProvider({
 		router.push(`/dashboard/${searchSpaceId}/team`);
 	}, [router, searchSpaceId]);
 
-	const handleLogout = useCallback(() => {
+	const handleLogout = useCallback(async () => {
 		try {
 			trackLogout();
 			resetUser();
+
+			// Best-effort cleanup of Electric SQL / PGlite
+			// Even if this fails, login-time cleanup will handle it
+			try {
+				await cleanupElectric();
+			} catch (err) {
+				console.warn("[Logout] Electric cleanup failed (will be handled on next login):", err);
+			}
+
 			if (typeof window !== "undefined") {
 				localStorage.removeItem("surfsense_bearer_token");
 				router.push("/");

surfsense_web/components/layout/ui/header/Header.tsx

@@ -3,6 +3,7 @@
 import { Moon, Sun } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { NotificationButton } from "@/components/notifications/NotificationButton";
 
 interface HeaderProps {
 	breadcrumb?: React.ReactNode;
@@ -29,6 +30,9 @@ export function Header({
 
 			{/* Right side - Actions */}
 			<div className="flex items-center gap-2">
+				{/* Notifications */}
+				<NotificationButton />
+
 				{/* Theme toggle */}
 				{onToggleTheme && (
 					<Tooltip>

surfsense_web/components/layout/ui/sidebar/AllPrivateChatsSidebar.tsx

@@ -34,7 +34,6 @@ import {
 	deleteThread,
 	fetchThreads,
 	searchThreads,
-	type ThreadListItem,
 	updateThread,
 } from "@/lib/chat/thread-persistence";
 import { cn } from "@/lib/utils";
@@ -410,7 +409,7 @@ export function AllPrivateChatsSidebar({
 								</div>
 							) : isSearchMode ? (
 								<div className="text-center py-8">
-									<Search className="h-12 w-12 mx-auto text-muted-foreground/50 mb-3" />
+									<Search className="h-12 w-12 mx-auto text-muted-foreground mb-3" />
 									<p className="text-sm text-muted-foreground">
 										{t("no_chats_found") || "No chats found"}
 									</p>
@@ -420,7 +419,7 @@ export function AllPrivateChatsSidebar({
 								</div>
 							) : (
 								<div className="text-center py-8">
-									<Lock className="h-12 w-12 mx-auto text-muted-foreground/50 mb-3" />
+									<Lock className="h-12 w-12 mx-auto text-muted-foreground mb-3" />
 									<p className="text-sm text-muted-foreground">
 										{showArchived
 											? t("no_archived_chats") || "No archived chats"

surfsense_web/components/layout/ui/sidebar/AllSharedChatsSidebar.tsx

@@ -34,7 +34,6 @@ import {
 	deleteThread,
 	fetchThreads,
 	searchThreads,
-	type ThreadListItem,
 	updateThread,
 } from "@/lib/chat/thread-persistence";
 import { cn } from "@/lib/utils";
@@ -410,7 +409,7 @@ export function AllSharedChatsSidebar({
 								</div>
 							) : isSearchMode ? (
 								<div className="text-center py-8">
-									<Search className="h-12 w-12 mx-auto text-muted-foreground/50 mb-3" />
+									<Search className="h-12 w-12 mx-auto text-muted-foreground mb-3" />
 									<p className="text-sm text-muted-foreground">
 										{t("no_chats_found") || "No chats found"}
 									</p>
@@ -420,7 +419,7 @@ export function AllSharedChatsSidebar({
 								</div>
 							) : (
 								<div className="text-center py-8">
-									<Users className="h-12 w-12 mx-auto text-muted-foreground/50 mb-3" />
+									<Users className="h-12 w-12 mx-auto text-muted-foreground mb-3" />
 									<p className="text-sm text-muted-foreground">
 										{showArchived
 											? t("no_archived_chats") || "No archived chats"

surfsense_web/components/layout/ui/sidebar/Sidebar.tsx

@@ -156,10 +156,10 @@ export function Sidebar({
 											<Button
 												variant="ghost"
 												size="icon"
-												className="h-5 w-5"
+												className="h-8 w-8 shrink-0 hover:bg-transparent hover:text-current focus-visible:ring-0"
 												onClick={onViewAllSharedChats}
 											>
-												<FolderOpen className="h-3.5 w-3.5" />
+												<FolderOpen className="h-4 w-4" />
 											</Button>
 										</TooltipTrigger>
 										<TooltipContent side="top">
@@ -197,10 +197,10 @@ export function Sidebar({
 											<Button
 												variant="ghost"
 												size="icon"
-												className="h-5 w-5"
+												className="h-8 w-8 shrink-0 hover:bg-transparent hover:text-current focus-visible:ring-0"
 												onClick={onViewAllPrivateChats}
 											>
-												<FolderOpen className="h-3.5 w-3.5" />
+												<FolderOpen className="h-4 w-4" />
 											</Button>
 										</TooltipTrigger>
 										<TooltipContent side="top">

surfsense_web/components/layout/ui/sidebar/SidebarSection.tsx

@@ -37,14 +37,14 @@ export function SidebarSection({
 
 				{/* Action button - visible on hover (always visible on mobile) */}
 				{action && (
-					<div className="shrink-0 opacity-0 group-hover/section:opacity-100 transition-opacity pr-1 flex items-center gap-0.5">
+					<div className="shrink-0 opacity-0 group-hover/section:opacity-100 transition-opacity pr-1 flex items-center">
 						{action}
 					</div>
 				)}
 
 				{/* Persistent action - always visible */}
 				{persistentAction && (
-					<div className="shrink-0 pr-1 flex items-center gap-0.5">{persistentAction}</div>
+					<div className="shrink-0 pr-1 flex items-center">{persistentAction}</div>
 				)}
 			</div>
 

surfsense_web/components/new-chat/chat-share-button.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useQueryClient } from "@tanstack/react-query";
-import { Globe, Loader2, Lock, Share2, Users } from "lucide-react";
+import { Loader2, Lock, Users } from "lucide-react";
 import { useCallback, useState } from "react";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
@@ -92,8 +92,7 @@ export function ChatShareButton({ thread, onVisibilityChange, className }: ChatS
 					variant="ghost"
 					size="sm"
 					className={cn(
-						"h-7 md:h-9 gap-1.5 md:gap-2 px-2 md:px-3 rounded-lg md:rounded-xl",
-						"border border-border/80 bg-background/50 backdrop-blur-sm",
+						"h-7 md:h-9 gap-1 md:gap-2 px-2 md:px-3 rounded-lg md:rounded-xl border border-border/80 bg-background/50 backdrop-blur-sm",
 						"hover:bg-muted/80 hover:border-border/30 transition-all duration-200",
 						"text-xs md:text-sm font-medium text-foreground",
 						"focus-visible:ring-0 focus-visible:ring-offset-0",
@@ -104,7 +103,6 @@ export function ChatShareButton({ thread, onVisibilityChange, className }: ChatS
 					<span className="hidden md:inline">
 						{currentVisibility === "PRIVATE" ? "Private" : "Shared"}
 					</span>
-					<Share2 className="size-3 md:size-3.5 text-muted-foreground" />
 				</Button>
 			</PopoverTrigger>
 
@@ -113,25 +111,13 @@ export function ChatShareButton({ thread, onVisibilityChange, className }: ChatS
 				align="end"
 				sideOffset={8}
 			>
-				<div className="p-3 md:p-4 border-b border-border/30">
-					<div className="flex items-center gap-2">
-						<Share2 className="size-4 md:size-5 text-primary" />
-						<div>
-							<h4 className="text-sm font-semibold">Share Chat</h4>
-							<p className="text-xs text-muted-foreground">
-								Control who can access this conversation
-							</p>
-						</div>
-					</div>
-				</div>
-
 				<div className="p-1.5 space-y-1">
 					{/* Updating overlay */}
 					{isUpdating && (
 						<div className="absolute inset-0 z-10 flex items-center justify-center bg-background/80 backdrop-blur-sm rounded-xl">
 							<div className="flex items-center gap-2 text-sm text-muted-foreground">
 								<Loader2 className="size-4 animate-spin" />
-								<span>Updating...</span>
+								<span>Updating</span>
 							</div>
 						</div>
 					)}
@@ -149,8 +135,8 @@ export function ChatShareButton({ thread, onVisibilityChange, className }: ChatS
 								className={cn(
 									"w-full flex items-start gap-2.5 px-2.5 py-2 rounded-md transition-all",
 									"hover:bg-accent/50 cursor-pointer",
-									"focus:outline-none focus:ring-2 focus:ring-primary/20",
-									isSelected && "bg-accent/80 ring-1 ring-primary/20"
+									"focus:outline-none",
+									isSelected && "bg-accent/80"
 								)}
 							>
 								<div
@@ -185,18 +171,6 @@ export function ChatShareButton({ thread, onVisibilityChange, className }: ChatS
 						);
 					})}
 				</div>
-
-				{/* Info footer */}
-				<div className="p-3 bg-muted/30 border-t border-border/30 rounded-b-xl">
-					<div className="flex items-start gap-2">
-						<Globe className="size-3.5 text-muted-foreground mt-0.5 shrink-0" />
-						<p className="text-[11px] text-muted-foreground leading-relaxed">
-							{currentVisibility === "PRIVATE"
-								? "This chat is private. Only you can view and interact with it."
-								: "This chat is shared. All search space members can view, continue the conversation, and delete it."}
-						</p>
-					</div>
-				</div>
 			</PopoverContent>
 		</Popover>
 	);

surfsense_web/components/new-chat/document-mention-picker.tsx

@@ -1,7 +1,6 @@
 "use client";
 
-import { useQuery } from "@tanstack/react-query";
-import { FileText } from "lucide-react";
+import { keepPreviousData, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
 	forwardRef,
 	useCallback,
@@ -12,9 +11,8 @@ import {
 	useState,
 } from "react";
 import { getConnectorIcon } from "@/contracts/enums/connectorIcons";
-import type { Document, GetDocumentsResponse } from "@/contracts/types/document.types";
+import type { Document, SearchDocumentTitlesResponse } from "@/contracts/types/document.types";
 import { documentsApiService } from "@/lib/apis/documents-api.service";
-import { cacheKeys } from "@/lib/query-client/cache-keys";
 import { cn } from "@/lib/utils";
 
 export interface DocumentMentionPickerRef {
@@ -29,16 +27,39 @@ interface DocumentMentionPickerProps {
 	onDone: () => void;
 	initialSelectedDocuments?: Pick<Document, "id" | "title" | "document_type">[];
 	externalSearch?: string;
+	/** Positioning styles for the container */
+	containerStyle?: React.CSSProperties;
 }
 
 const PAGE_SIZE = 20;
+const MIN_SEARCH_LENGTH = 2;
+const DEBOUNCE_MS = 100;
 
-function useDebounced<T>(value: T, delay = 300) {
+/**
+ * Custom debounce hook that delays value updates until user input stabilizes.
+ * Preferred over throttling for search inputs as it reduces API request frequency
+ * and prevents race conditions from stale responses overtaking recent ones.
+ */
+function useDebounced<T>(value: T, delay = DEBOUNCE_MS) {
 	const [debounced, setDebounced] = useState(value);
+	const timeoutRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+
 	useEffect(() => {
-		const t = setTimeout(() => setDebounced(value), delay);
-		return () => clearTimeout(t);
+		if (timeoutRef.current) {
+			clearTimeout(timeoutRef.current);
+		}
+
+		timeoutRef.current = setTimeout(() => {
+			setDebounced(value);
+		}, delay);
+
+		return () => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current);
+			}
+		};
 	}, [value, delay]);
+
 	return debounced;
 }
 
@@ -46,17 +67,27 @@ export const DocumentMentionPicker = forwardRef<
 	DocumentMentionPickerRef,
 	DocumentMentionPickerProps
 >(function DocumentMentionPicker(
-	{ searchSpaceId, onSelectionChange, onDone, initialSelectedDocuments = [], externalSearch = "" },
+	{
+		searchSpaceId,
+		onSelectionChange,
+		onDone,
+		initialSelectedDocuments = [],
+		externalSearch = "",
+		containerStyle,
+	},
 	ref
 ) {
-	// Use external search
+	const queryClient = useQueryClient();
+
+	// Debounced search value to minimize API calls and prevent race conditions
 	const search = externalSearch;
-	const debouncedSearch = useDebounced(search, 150);
+	const debouncedSearch = useDebounced(search, DEBOUNCE_MS);
 	const [highlightedIndex, setHighlightedIndex] = useState(0);
 	const itemRefs = useRef<Map<number, HTMLButtonElement>>(new Map());
 	const scrollContainerRef = useRef<HTMLDivElement>(null);
+	const shouldScrollRef = useRef(false); // Keyboard navigation scroll flag
 
-	// State for pagination
+	// Pagination state for infinite scroll
 	const [accumulatedDocuments, setAccumulatedDocuments] = useState<
 		Pick<Document, "id" | "title" | "document_type">[]
 	>([]);
@@ -64,74 +95,119 @@ export const DocumentMentionPicker = forwardRef<
 	const [hasMore, setHasMore] = useState(false);
 	const [isLoadingMore, setIsLoadingMore] = useState(false);
 
-	// Reset pagination when search or search space changes
-	// biome-ignore lint/correctness/useExhaustiveDependencies: intentionally reset pagination when search/space changes
+	/**
+	 * Search Strategy:
+	 * - Single character (length === 1): Client-side filtering for instant results
+	 * - Two or more characters (length >= 2): Server-side search with pg_trgm index
+	 * This hybrid approach optimizes UX by providing immediate feedback for short queries
+	 * while leveraging efficient database indexing for longer, more specific searches.
+	 */
+	const isSearchValid = debouncedSearch.trim().length >= MIN_SEARCH_LENGTH;
+	const shouldSearch = debouncedSearch.trim().length > 0;
+	const isSingleCharSearch = debouncedSearch.trim().length === 1;
+
+	// Prefetch initial data on mount for instant display when picker opens
+	useEffect(() => {
+		if (!searchSpaceId) return;
+
+		const prefetchParams = {
+			search_space_id: searchSpaceId,
+			page: 0,
+			page_size: PAGE_SIZE,
+		};
+
+		queryClient.prefetchQuery({
+			queryKey: ["document-titles", prefetchParams],
+			queryFn: () => documentsApiService.searchDocumentTitles({ queryParams: prefetchParams }),
+			staleTime: 60 * 1000,
+		});
+
+		queryClient.prefetchQuery({
+			queryKey: ["surfsense-docs-mention", "", false],
+			queryFn: () =>
+				documentsApiService.getSurfsenseDocs({
+					queryParams: { page: 0, page_size: PAGE_SIZE },
+				}),
+			staleTime: 3 * 60 * 1000,
+		});
+	}, [searchSpaceId, queryClient]);
+
+	// Reset pagination state when search query or search space changes.
+	// Documents are not cleared to maintain visual continuity during fetches.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: Intentional reset on search/space change
 	useEffect(() => {
-		setAccumulatedDocuments([]);
 		setCurrentPage(0);
 		setHasMore(false);
 		setHighlightedIndex(0);
 	}, [debouncedSearch, searchSpaceId]);
 
-	// Query params for initial fetch (page 0)
-	const fetchQueryParams = useMemo(
+	// Query parameters for lightweight title search endpoint
+	const titleSearchParams = useMemo(
 		() => ({
 			search_space_id: searchSpaceId,
 			page: 0,
 			page_size: PAGE_SIZE,
+			...(isSearchValid ? { title: debouncedSearch.trim() } : {}),
 		}),
-		[searchSpaceId]
+		[searchSpaceId, debouncedSearch, isSearchValid]
 	);
 
-	const searchQueryParams = useMemo(() => {
-		return {
-			search_space_id: searchSpaceId,
-			page: 0,
-			page_size: PAGE_SIZE,
-			title: debouncedSearch,
-		};
-	}, [debouncedSearch, searchSpaceId]);
-
 	const surfsenseDocsQueryParams = useMemo(() => {
 		const params: { page: number; page_size: number; title?: string } = {
 			page: 0,
 			page_size: PAGE_SIZE,
 		};
-		if (debouncedSearch.trim()) {
-			params.title = debouncedSearch;
+		if (isSearchValid) {
+			params.title = debouncedSearch.trim();
 		}
 		return params;
-	}, [debouncedSearch]);
+	}, [debouncedSearch, isSearchValid]);
 
-	// Use query for fetching first page of documents
-	const { data: documents, isLoading: isDocumentsLoading } = useQuery({
-		queryKey: cacheKeys.documents.withQueryParams(fetchQueryParams),
-		queryFn: () => documentsApiService.getDocuments({ queryParams: fetchQueryParams }),
-		staleTime: 3 * 60 * 1000,
-		enabled: !!searchSpaceId && !debouncedSearch.trim() && currentPage === 0,
+	/**
+	 * TanStack Query for document title search.
+	 * - Uses AbortSignal for automatic request cancellation on query key changes
+	 * - placeholderData: keepPreviousData maintains UI stability during fetches
+	 * - Only triggers server-side search when isSearchValid (2+ characters)
+	 */
+	const { data: titleSearchResults, isLoading: isTitleSearchLoading } = useQuery({
+		queryKey: ["document-titles", titleSearchParams],
+		queryFn: ({ signal }) =>
+			documentsApiService.searchDocumentTitles({ queryParams: titleSearchParams }, signal),
+		staleTime: 60 * 1000,
+		enabled: !!searchSpaceId && currentPage === 0 && (!shouldSearch || isSearchValid),
+		placeholderData: keepPreviousData,
 	});
 
-	// Searching - first page
-	const { data: searchedDocuments, isLoading: isSearchedDocumentsLoading } = useQuery({
-		queryKey: cacheKeys.documents.withQueryParams(searchQueryParams),
-		queryFn: () => documentsApiService.searchDocuments({ queryParams: searchQueryParams }),
-		staleTime: 3 * 60 * 1000,
-		enabled: !!searchSpaceId && !!debouncedSearch.trim() && currentPage === 0,
-	});
-
-	// Use query for fetching first page of SurfSense docs
+	/**
+	 * TanStack Query for SurfSense documentation.
+	 * - Uses AbortSignal for automatic request cancellation
+	 * - placeholderData: keepPreviousData prevents UI flicker during refetches
+	 */
 	const { data: surfsenseDocs, isLoading: isSurfsenseDocsLoading } = useQuery({
-		queryKey: ["surfsense-docs-mention", debouncedSearch],
-		queryFn: () => documentsApiService.getSurfsenseDocs({ queryParams: surfsenseDocsQueryParams }),
+		queryKey: ["surfsense-docs-mention", debouncedSearch, isSearchValid],
+		queryFn: ({ signal }) =>
+			documentsApiService.getSurfsenseDocs({ queryParams: surfsenseDocsQueryParams }, signal),
 		staleTime: 3 * 60 * 1000,
+		enabled: !shouldSearch || isSearchValid,
+		placeholderData: keepPreviousData,
 	});
 
-	// Update accumulated documents when first page loads - combine both sources
+	// Post-fetch filter to eliminate false positives from backend fuzzy matching
+	const filterBySearchTerm = useCallback(
+		(docs: Pick<Document, "id" | "title" | "document_type">[]) => {
+			if (!isSearchValid) return docs; // No filtering when not searching
+			const searchLower = debouncedSearch.trim().toLowerCase();
+			return docs.filter((doc) => doc.title.toLowerCase().includes(searchLower));
+		},
+		[debouncedSearch, isSearchValid]
+	);
+
+	// Combine and update document list when first page data arrives
 	useEffect(() => {
 		if (currentPage === 0) {
 			const combinedDocs: Pick<Document, "id" | "title" | "document_type">[] = [];
 
-			// Add SurfSense docs first (they appear at top)
+			// SurfSense docs displayed first in the list
 			if (surfsenseDocs?.items) {
 				for (const doc of surfsenseDocs.items) {
 					combinedDocs.push({
@@ -142,24 +218,16 @@ export const DocumentMentionPicker = forwardRef<
 				}
 			}
 
-			// Add regular documents
-			if (debouncedSearch.trim()) {
-				if (searchedDocuments?.items) {
-					combinedDocs.push(...searchedDocuments.items);
-					setHasMore(searchedDocuments.has_more);
-				}
-			} else {
-				if (documents?.items) {
-					combinedDocs.push(...documents.items);
-					setHasMore(documents.has_more);
-				}
+			if (titleSearchResults?.items) {
+				combinedDocs.push(...titleSearchResults.items);
+				setHasMore(titleSearchResults.has_more);
 			}
 
-			setAccumulatedDocuments(combinedDocs);
+			setAccumulatedDocuments(filterBySearchTerm(combinedDocs));
 		}
-	}, [documents, searchedDocuments, surfsenseDocs, debouncedSearch, currentPage]);
+	}, [titleSearchResults, surfsenseDocs, currentPage, filterBySearchTerm]);
 
-	// Function to load next page
+	// Load next page for infinite scroll pagination
 	const loadNextPage = useCallback(async () => {
 		if (isLoadingMore || !hasMore) return;
 
@@ -167,23 +235,15 @@ export const DocumentMentionPicker = forwardRef<
 		setIsLoadingMore(true);
 
 		try {
-			let response: GetDocumentsResponse;
-			if (debouncedSearch.trim()) {
-				const queryParams = {
-					search_space_id: searchSpaceId,
-					page: nextPage,
-					page_size: PAGE_SIZE,
-					title: debouncedSearch,
-				};
-				response = await documentsApiService.searchDocuments({ queryParams });
-			} else {
-				const queryParams = {
-					search_space_id: searchSpaceId,
-					page: nextPage,
-					page_size: PAGE_SIZE,
-				};
-				response = await documentsApiService.getDocuments({ queryParams });
-			}
+			const queryParams = {
+				search_space_id: searchSpaceId,
+				page: nextPage,
+				page_size: PAGE_SIZE,
+				...(isSearchValid ? { title: debouncedSearch.trim() } : {}),
+			};
+			const response: SearchDocumentTitlesResponse = await documentsApiService.searchDocumentTitles(
+				{ queryParams }
+			);
 
 			setAccumulatedDocuments((prev) => [...prev, ...response.items]);
 			setHasMore(response.has_more);
@@ -193,15 +253,14 @@ export const DocumentMentionPicker = forwardRef<
 		} finally {
 			setIsLoadingMore(false);
 		}
-	}, [currentPage, hasMore, isLoadingMore, debouncedSearch, searchSpaceId]);
+	}, [currentPage, hasMore, isLoadingMore, debouncedSearch, searchSpaceId, isSearchValid]);
 
-	// Infinite scroll handler
+	// Trigger pagination when user scrolls near the bottom (50px threshold)
 	const handleScroll = useCallback(
 		(e: React.UIEvent<HTMLDivElement>) => {
 			const target = e.currentTarget;
 			const scrollBottom = target.scrollHeight - target.scrollTop - target.clientHeight;
 
-			// Load more when within 50px of bottom
 			if (scrollBottom < 50 && hasMore && !isLoadingMore) {
 				loadNextPage();
 			}
@@ -209,13 +268,26 @@ export const DocumentMentionPicker = forwardRef<
 		[hasMore, isLoadingMore, loadNextPage]
 	);
 
-	const actualDocuments = accumulatedDocuments;
-	const actualLoading =
-		((debouncedSearch.trim() ? isSearchedDocumentsLoading : isDocumentsLoading) ||
-			isSurfsenseDocsLoading) &&
-		currentPage === 0;
+	/**
+	 * Client-side filtering for single character searches.
+	 * Filters cached documents locally for instant feedback without additional API calls.
+	 * Server-side search is reserved for 2+ character queries to leverage database indexing.
+	 */
+	const clientFilteredDocs = useMemo(() => {
+		if (!isSingleCharSearch) return null;
+		const searchLower = debouncedSearch.trim().toLowerCase();
+		return accumulatedDocuments.filter((doc) => doc.title.toLowerCase().includes(searchLower));
+	}, [isSingleCharSearch, debouncedSearch, accumulatedDocuments]);
 
-	// Split documents into SurfSense docs and user docs for grouped rendering
+	// Select data source based on search length: client-filtered for single char, server results for 2+
+	const actualDocuments = isSingleCharSearch ? (clientFilteredDocs ?? []) : accumulatedDocuments;
+	// Only show loading spinner on initial load (no documents yet), not during subsequent searches
+	const actualLoading =
+		(isTitleSearchLoading || isSurfsenseDocsLoading) &&
+		currentPage === 0 &&
+		!isSingleCharSearch &&
+		accumulatedDocuments.length === 0;
+	// Partition documents by type for grouped UI rendering
 	const surfsenseDocsList = useMemo(
 		() => actualDocuments.filter((doc) => doc.document_type === "SURFSENSE_DOCS"),
 		[actualDocuments]
@@ -225,13 +297,13 @@ export const DocumentMentionPicker = forwardRef<
 		[actualDocuments]
 	);
 
-	// Track already selected documents using unique key (document_type:id) to avoid ID collisions
+	// Track selected documents with composite key (document_type:id) to prevent cross-type ID collisions
 	const selectedKeys = useMemo(
 		() => new Set(initialSelectedDocuments.map((d) => `${d.document_type}:${d.id}`)),
 		[initialSelectedDocuments]
 	);
 
-	// Filter out already selected documents for navigation
+	// Exclude already-selected documents from keyboard navigation
 	const selectableDocuments = useMemo(
 		() => actualDocuments.filter((doc) => !selectedKeys.has(`${doc.document_type}:${doc.id}`)),
 		[actualDocuments, selectedKeys]
@@ -245,15 +317,44 @@ export const DocumentMentionPicker = forwardRef<
 		[initialSelectedDocuments, onSelectionChange, onDone]
 	);
 
-	// Scroll highlighted item into view
+	// Auto-scroll highlighted item into view (keyboard navigation only, not mouse hover)
 	useEffect(() => {
-		const item = itemRefs.current.get(highlightedIndex);
-		if (item) {
-			item.scrollIntoView({ block: "nearest", behavior: "smooth" });
+		if (!shouldScrollRef.current) {
+			return;
 		}
+		shouldScrollRef.current = false;
+
+		const rafId = requestAnimationFrame(() => {
+			const item = itemRefs.current.get(highlightedIndex);
+			const container = scrollContainerRef.current;
+
+			if (item && container) {
+				const itemRect = item.getBoundingClientRect();
+				const containerRect = container.getBoundingClientRect();
+				const padding = 8;
+				const isAboveViewport = itemRect.top < containerRect.top + padding;
+				const isBelowViewport = itemRect.bottom > containerRect.bottom - padding;
+
+				if (isAboveViewport || isBelowViewport) {
+					const itemOffsetTop = item.offsetTop;
+					const containerHeight = container.clientHeight;
+					const itemHeight = item.offsetHeight;
+					const targetScrollTop = itemOffsetTop - containerHeight / 2 + itemHeight / 2;
+					const maxScrollTop = container.scrollHeight - containerHeight;
+					const clampedScrollTop = Math.max(0, Math.min(targetScrollTop, maxScrollTop));
+
+					container.scrollTo({
+						top: clampedScrollTop,
+						behavior: "smooth",
+					});
+				}
+			}
+		});
+
+		return () => cancelAnimationFrame(rafId);
 	}, [highlightedIndex]);
 
-	// Reset highlighted index when external search changes
+	// Reset highlight position when search query changes
 	const prevSearchRef = useRef(search);
 	if (prevSearchRef.current !== search) {
 		prevSearchRef.current = search;
@@ -262,7 +363,7 @@ export const DocumentMentionPicker = forwardRef<
 		}
 	}
 
-	// Expose methods to parent via ref
+	// Expose navigation and selection methods to parent component via ref
 	useImperativeHandle(
 		ref,
 		() => ({
@@ -272,16 +373,18 @@ export const DocumentMentionPicker = forwardRef<
 				}
 			},
 			moveUp: () => {
+				shouldScrollRef.current = true;
 				setHighlightedIndex((prev) => (prev > 0 ? prev - 1 : selectableDocuments.length - 1));
 			},
 			moveDown: () => {
+				shouldScrollRef.current = true;
 				setHighlightedIndex((prev) => (prev < selectableDocuments.length - 1 ? prev + 1 : 0));
 			},
 		}),
 		[selectableDocuments, highlightedIndex, handleSelectDocument]
 	);
 
-	// Handle keyboard navigation
+	// Keyboard navigation handler for arrow keys, Enter, and Escape
 	const handleKeyDown = useCallback(
 		(e: React.KeyboardEvent) => {
 			if (selectableDocuments.length === 0) return;
@@ -289,10 +392,12 @@ export const DocumentMentionPicker = forwardRef<
 			switch (e.key) {
 				case "ArrowDown":
 					e.preventDefault();
+					shouldScrollRef.current = true;
 					setHighlightedIndex((prev) => (prev < selectableDocuments.length - 1 ? prev + 1 : 0));
 					break;
 				case "ArrowUp":
 					e.preventDefault();
+					shouldScrollRef.current = true;
 					setHighlightedIndex((prev) => (prev > 0 ? prev - 1 : selectableDocuments.length - 1));
 					break;
 				case "Enter":
@@ -310,14 +415,24 @@ export const DocumentMentionPicker = forwardRef<
 		[selectableDocuments, highlightedIndex, handleSelectDocument, onDone]
 	);
 
+	// Hide popup when there are no documents to display (regardless of fetch state)
+	// Search continues in background; popup reappears when results arrive
+	if (!actualLoading && actualDocuments.length === 0) {
+		return null;
+	}
+
 	return (
 		<div
-			className="flex flex-col w-[280px] sm:w-[320px] bg-popover rounded-lg"
+			className="fixed shadow-2xl rounded-lg border border-border overflow-hidden bg-popover flex flex-col w-[280px] sm:w-[320px]"
+			style={{
+				zIndex: 9999,
+				...containerStyle,
+			}}
 			onKeyDown={handleKeyDown}
 			role="listbox"
 			tabIndex={-1}
 		>
-			{/* Document List - Shows max 5 items on mobile, 7-8 items on desktop */}
+			{/* Scrollable document list with responsive height */}
 			<div
 				ref={scrollContainerRef}
 				className="max-h-[180px] sm:max-h-[280px] overflow-y-auto"
@@ -327,17 +442,12 @@ export const DocumentMentionPicker = forwardRef<
 					<div className="flex items-center justify-center py-4">
 						<div className="animate-spin h-5 w-5 border-2 border-primary border-t-transparent rounded-full" />
 					</div>
-				) : actualDocuments.length === 0 ? (
-					<div className="flex flex-col items-center justify-center py-4 text-center px-4">
-						<FileText className="h-5 w-5 text-muted-foreground/50 mb-1" />
-						<p className="text-sm text-muted-foreground">No documents found</p>
-					</div>
-				) : (
-					<div className="py-1">
-						{/* SurfSense Documentation Section */}
+				) : actualDocuments.length > 0 ? (
+					<div className="py-1 px-2">
+						{/* SurfSense Documentation */}
 						{surfsenseDocsList.length > 0 && (
 							<>
-								<div className="sticky top-0 z-10 px-3 py-2 text-xs font-bold uppercase tracking-wider bg-muted text-foreground/80 border-b border-border">
+								<div className="px-3 py-2 text-xs font-bold text-muted-foreground/55">
 									SurfSense Docs
 								</div>
 								{surfsenseDocsList.map((doc) => {
@@ -365,7 +475,7 @@ export const DocumentMentionPicker = forwardRef<
 											}}
 											disabled={isAlreadySelected}
 											className={cn(
-												"w-full flex items-center gap-2 px-3 py-2 text-left transition-colors",
+												"w-full flex items-center gap-2 px-3 py-2 text-left transition-colors rounded-md",
 												isAlreadySelected ? "opacity-50 cursor-not-allowed" : "cursor-pointer",
 												isHighlighted && "bg-accent"
 											)}
@@ -382,10 +492,10 @@ export const DocumentMentionPicker = forwardRef<
 							</>
 						)}
 
-						{/* User Documents Section */}
+						{/* User Documents */}
 						{userDocsList.length > 0 && (
 							<>
-								<div className="sticky top-0 z-10 px-3 py-2 text-xs font-bold uppercase tracking-wider bg-muted text-foreground/80 border-b border-border">
+								<div className="px-3 py-2 text-xs font-bold text-muted-foreground/55">
 									Your Documents
 								</div>
 								{userDocsList.map((doc) => {
@@ -413,7 +523,7 @@ export const DocumentMentionPicker = forwardRef<
 											}}
 											disabled={isAlreadySelected}
 											className={cn(
-												"w-full flex items-center gap-2 px-3 py-2 text-left transition-colors",
+												"w-full flex items-center gap-2 px-3 py-2 text-left transition-colors rounded-md",
 												isAlreadySelected ? "opacity-50 cursor-not-allowed" : "cursor-pointer",
 												isHighlighted && "bg-accent"
 											)}
@@ -430,14 +540,14 @@ export const DocumentMentionPicker = forwardRef<
 							</>
 						)}
 
-						{/* Loading indicator for additional pages */}
+						{/* Pagination loading indicator */}
 						{isLoadingMore && (
 							<div className="flex items-center justify-center py-2">
 								<div className="animate-spin h-4 w-4 border-2 border-primary border-t-transparent rounded-full" />
 							</div>
 						)}
 					</div>
-				)}
+				) : null}
 			</div>
 		</div>
 	);

surfsense_web/components/notifications/NotificationButton.tsx

@@ -0,0 +1,61 @@
+"use client";
+
+import { Bell } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { useNotifications } from "@/hooks/use-notifications";
+import { useAtomValue } from "jotai";
+import { currentUserAtom } from "@/atoms/user/user-query.atoms";
+import { NotificationPopup } from "./NotificationPopup";
+import { cn } from "@/lib/utils";
+import { useParams } from "next/navigation";
+
+export function NotificationButton() {
+	const { data: user } = useAtomValue(currentUserAtom);
+	const params = useParams();
+
+	const userId = user?.id ? String(user.id) : null;
+	// Get searchSpaceId from URL params - the component is rendered within /dashboard/[search_space_id]/
+	const searchSpaceId = params?.search_space_id ? Number(params.search_space_id) : null;
+
+	const { notifications, unreadCount, loading, markAsRead, markAllAsRead } = useNotifications(
+		userId,
+		searchSpaceId
+	);
+
+	return (
+		<Popover>
+			<Tooltip>
+				<TooltipTrigger asChild>
+					<PopoverTrigger asChild>
+						<Button variant="outline" size="icon" className="h-8 w-8 relative">
+							<Bell className="h-4 w-4" />
+							{unreadCount > 0 && (
+								<span
+									className={cn(
+										"absolute -top-1 -right-1 flex h-5 w-5 items-center justify-center rounded-full bg-black text-[10px] font-medium text-white dark:bg-zinc-800 dark:text-zinc-50",
+										unreadCount > 9 && "px-1"
+									)}
+								>
+									{unreadCount > 99 ? "99+" : unreadCount}
+								</span>
+							)}
+							<span className="sr-only">Notifications</span>
+						</Button>
+					</PopoverTrigger>
+				</TooltipTrigger>
+				<TooltipContent>Notifications</TooltipContent>
+			</Tooltip>
+			<PopoverContent align="end" className="w-80 p-0">
+				<NotificationPopup
+					notifications={notifications}
+					unreadCount={unreadCount}
+					loading={loading}
+					markAsRead={markAsRead}
+					markAllAsRead={markAllAsRead}
+				/>
+			</PopoverContent>
+		</Popover>
+	);
+}

surfsense_web/components/notifications/NotificationPopup.tsx

@@ -0,0 +1,127 @@
+"use client";
+
+import { Bell, CheckCheck, Loader2, AlertCircle, CheckCircle2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { Separator } from "@/components/ui/separator";
+import type { Notification } from "@/hooks/use-notifications";
+import { formatDistanceToNow } from "date-fns";
+import { cn } from "@/lib/utils";
+
+interface NotificationPopupProps {
+	notifications: Notification[];
+	unreadCount: number;
+	loading: boolean;
+	markAsRead: (id: number) => Promise<boolean>;
+	markAllAsRead: () => Promise<boolean>;
+}
+
+export function NotificationPopup({
+	notifications,
+	unreadCount,
+	loading,
+	markAsRead,
+	markAllAsRead,
+}: NotificationPopupProps) {
+	const handleMarkAsRead = async (id: number) => {
+		await markAsRead(id);
+	};
+
+	const handleMarkAllAsRead = async () => {
+		await markAllAsRead();
+	};
+
+	const formatTime = (dateString: string) => {
+		try {
+			return formatDistanceToNow(new Date(dateString), { addSuffix: true });
+		} catch {
+			return "Recently";
+		}
+	};
+
+	const getStatusIcon = (notification: Notification) => {
+		const status = notification.metadata?.status as string | undefined;
+
+		switch (status) {
+			case "in_progress":
+				return <Loader2 className="h-4 w-4 text-foreground animate-spin" />;
+			case "completed":
+				return <CheckCircle2 className="h-4 w-4 text-green-500" />;
+			case "failed":
+				return <AlertCircle className="h-4 w-4 text-red-500" />;
+			default:
+				return <Bell className="h-4 w-4 text-muted-foreground" />;
+		}
+	};
+
+	return (
+		<div className="flex flex-col w-80 max-w-[calc(100vw-2rem)]">
+			{/* Header */}
+			<div className="flex items-center justify-between px-4 py-3 border-b">
+				<div className="flex items-center gap-2">
+					<h3 className="font-semibold text-sm">Notifications</h3>
+				</div>
+				{unreadCount > 0 && (
+					<Button variant="ghost" size="sm" onClick={handleMarkAllAsRead} className="h-7 text-xs">
+						<CheckCheck className="h-3.5 w-3.5 mr-0" />
+						Mark all read
+					</Button>
+				)}
+			</div>
+
+			{/* Notifications List */}
+			<ScrollArea className="h-[400px]">
+				{loading ? (
+					<div className="flex items-center justify-center py-8">
+						<Loader2 className="h-5 w-5 animate-spin text-foreground" />
+					</div>
+				) : notifications.length === 0 ? (
+					<div className="flex flex-col items-center justify-center py-8 px-4 text-center">
+						<Bell className="h-8 w-8 text-muted-foreground mb-2" />
+						<p className="text-sm text-muted-foreground">No notifications</p>
+					</div>
+				) : (
+					<div className="pt-0 pb-2">
+						{notifications.map((notification, index) => (
+							<div key={notification.id}>
+								<button
+									type="button"
+									onClick={() => !notification.read && handleMarkAsRead(notification.id)}
+									className={cn(
+										"w-full px-4 py-3 text-left hover:bg-accent transition-colors",
+										!notification.read && "bg-accent/50"
+									)}
+								>
+									<div className="flex items-start gap-3 overflow-hidden">
+										<div className="flex-shrink-0 mt-0.5">{getStatusIcon(notification)}</div>
+										<div className="flex-1 min-w-0 overflow-hidden">
+											<div className="flex items-start justify-between gap-2 mb-1">
+												<p
+													className={cn(
+														"text-xs font-medium break-all",
+														!notification.read && "font-semibold"
+													)}
+												>
+													{notification.title}
+												</p>
+											</div>
+											<p className="text-[11px] text-muted-foreground break-all line-clamp-2">
+												{notification.message}
+											</p>
+											<div className="flex items-center justify-between mt-2">
+												<span className="text-[10px] text-muted-foreground">
+													{formatTime(notification.created_at)}
+												</span>
+											</div>
+										</div>
+									</div>
+								</button>
+								{index < notifications.length - 1 && <Separator />}
+							</div>
+						))}
+					</div>
+				)}
+			</ScrollArea>
+		</div>
+	);
+}

surfsense_web/components/providers/ElectricProvider.tsx

@@ -0,0 +1,132 @@
+"use client";
+
+import { useEffect, useState, useRef } from "react";
+import { useAtomValue } from "jotai";
+import { currentUserAtom } from "@/atoms/user/user-query.atoms";
+import {
+	initElectric,
+	cleanupElectric,
+	isElectricInitialized,
+	type ElectricClient,
+} from "@/lib/electric/client";
+import { ElectricContext } from "@/lib/electric/context";
+
+interface ElectricProviderProps {
+	children: React.ReactNode;
+}
+
+/**
+ * ElectricProvider initializes the Electric SQL client with user-specific PGlite database
+ * and provides it to children via context.
+ *
+ * KEY BEHAVIORS:
+ * 1. Single initialization point - only this provider creates the Electric client
+ * 2. Creates user-specific database (isolated per user)
+ * 3. Cleans up other users' databases on login
+ * 4. Re-initializes when user changes
+ * 5. Provides client via context - hooks should use useElectricClient()
+ */
+export function ElectricProvider({ children }: ElectricProviderProps) {
+	const [electricClient, setElectricClient] = useState<ElectricClient | null>(null);
+	const [error, setError] = useState<Error | null>(null);
+	const {
+		data: user,
+		isSuccess: isUserLoaded,
+		isError: isUserError,
+	} = useAtomValue(currentUserAtom);
+	const previousUserIdRef = useRef<string | null>(null);
+	const initializingRef = useRef(false);
+
+	useEffect(() => {
+		// Skip on server side
+		if (typeof window === "undefined") return;
+
+		// If no user is logged in, don't initialize Electric
+		// The app can still function without real-time sync for non-authenticated pages
+		if (!isUserLoaded || !user?.id) {
+			// If we had a previous user and now logged out, cleanup
+			if (previousUserIdRef.current && isElectricInitialized()) {
+				console.log("[ElectricProvider] User logged out, cleaning up...");
+				cleanupElectric().then(() => {
+					previousUserIdRef.current = null;
+					setElectricClient(null);
+				});
+			}
+			return;
+		}
+
+		const userId = String(user.id);
+
+		// If already initialized for THIS user, skip
+		if (electricClient && previousUserIdRef.current === userId) {
+			return;
+		}
+
+		// Prevent concurrent initialization attempts
+		if (initializingRef.current) {
+			return;
+		}
+
+		// User changed or first initialization
+		initializingRef.current = true;
+		let mounted = true;
+
+		async function init() {
+			try {
+				console.log(`[ElectricProvider] Initializing for user: ${userId}`);
+
+				// If different user was previously initialized, cleanup will happen inside initElectric
+				const client = await initElectric(userId);
+
+				if (mounted) {
+					previousUserIdRef.current = userId;
+					setElectricClient(client);
+					setError(null);
+					console.log(`[ElectricProvider] ✅ Ready for user: ${userId}`);
+				}
+			} catch (err) {
+				console.error("[ElectricProvider] Failed to initialize:", err);
+				if (mounted) {
+					setError(err instanceof Error ? err : new Error("Failed to initialize Electric SQL"));
+					// Set client to null so hooks know initialization failed
+					setElectricClient(null);
+				}
+			} finally {
+				if (mounted) {
+					initializingRef.current = false;
+				}
+			}
+		}
+
+		init();
+
+		return () => {
+			mounted = false;
+		};
+	}, [user?.id, isUserLoaded, electricClient]);
+
+	// For non-authenticated pages (like landing page), render immediately with null context
+	// Also render immediately if user query failed (e.g., token expired)
+	if (!isUserLoaded || !user?.id || isUserError) {
+		return <ElectricContext.Provider value={null}>{children}</ElectricContext.Provider>;
+	}
+
+	// Show loading state while initializing for authenticated users
+	if (!electricClient && !error) {
+		return (
+			<ElectricContext.Provider value={null}>
+				<div className="flex items-center justify-center min-h-screen">
+					<div className="text-muted-foreground">Initializing...</div>
+				</div>
+			</ElectricContext.Provider>
+		);
+	}
+
+	// If there's an error, still render but warn
+	if (error) {
+		console.warn("[ElectricProvider] Initialization failed, sync may not work:", error.message);
+	}
+
+	// Provide the Electric client to children
+	return <ElectricContext.Provider value={electricClient}>{children}</ElectricContext.Provider>;
+}

surfsense_web/components/shared/llm-config-form.tsx

@@ -560,7 +560,7 @@ export function LLMConfigForm({
 						{isSubmitting ? (
 							<>
 								<Loader2 className="h-3.5 w-3.5 sm:h-4 sm:w-4 animate-spin" />
-								{mode === "edit" ? "Updating..." : "Creating..."}
+								{mode === "edit" ? "Updating..." : "Creating"}
 							</>
 						) : (
 							<>

surfsense_web/components/sources/DocumentUploadTab.tsx

@@ -3,7 +3,6 @@
 import { useAtom } from "jotai";
 import { CheckCircle2, FileType, Info, Loader2, Tag, Upload, X } from "lucide-react";
 import { AnimatePresence, motion } from "motion/react";
-import { useRouter } from "next/navigation";
 import { useTranslations } from "next-intl";
 import { useCallback, useMemo, useRef, useState } from "react";
 import { useDropzone } from "react-dropzone";
@@ -121,7 +120,6 @@ export function DocumentUploadTab({
 	onAccordionStateChange,
 }: DocumentUploadTabProps) {
 	const t = useTranslations("upload_documents");
-	const router = useRouter();
 	const [files, setFiles] = useState<File[]>([]);
 	const [uploadProgress, setUploadProgress] = useState(0);
 	const [accordionValue, setAccordionValue] = useState<string>("");
@@ -224,7 +222,7 @@ export function DocumentUploadTab({
 					setUploadProgress(100);
 					trackDocumentUploadSuccess(Number(searchSpaceId), files.length);
 					toast(t("upload_initiated"), { description: t("upload_initiated_desc") });
-					onSuccess?.() || router.push(`/dashboard/${searchSpaceId}/documents`);
+					onSuccess?.();
 				},
 				onError: (error: unknown) => {
 					clearInterval(progressInterval);

surfsense_web/components/tool-ui/generate-podcast.tsx

@@ -98,7 +98,7 @@ function PodcastGeneratingState({ title }: { title: string }) {
 					<h3 className="font-semibold text-foreground text-lg">{title}</h3>
 					<div className="mt-2 flex items-center gap-2 text-muted-foreground">
 						<Loader2Icon className="size-4 animate-spin" />
-						<span className="text-sm">Generating podcast... This may take a few minutes</span>
+						<span className="text-sm">Generating podcast. This may take a few minutes</span>
 					</div>
 					<div className="mt-3">
 						<div className="h-1.5 w-full overflow-hidden rounded-full bg-primary/10">

surfsense_web/components/ui/tooltip.tsx

@@ -42,7 +42,7 @@ function TooltipContent({
 				data-slot="tooltip-content"
 				sideOffset={sideOffset}
 				className={cn(
-					"bg-popover text-popover-foreground fill-popover shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit rounded-md px-3 py-1.5 text-xs text-balance",
+					"bg-black text-white font-medium shadow-xl px-3 py-1.5 dark:bg-zinc-800 dark:text-zinc-50 border-none animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit rounded-md text-xs text-balance",
 					className
 				)}
 				{...props}

surfsense_web/content/docs/connectors/meta.json

@@ -19,5 +19,5 @@
 		"elasticsearch",
 		"bookstack"
 	],
-	"defaultOpen": true
+	"defaultOpen": false
 }

surfsense_web/content/docs/how-to/electric-sql.mdx

@@ -0,0 +1,275 @@
+---
+title: Electric SQL
+description: Setting up Electric SQL for real-time data synchronization in SurfSense
+---
+
+# Electric SQL
+
+[Electric SQL](https://electric-sql.com/) enables real-time data synchronization in SurfSense, providing instant updates for notifications, document indexing status, and connector sync progress without manual refresh. The frontend uses [PGlite](https://pglite.dev/) (a lightweight PostgreSQL in the browser) to maintain a local database that syncs with the backend via Electric SQL.
+
+## What Does Electric SQL Do?
+
+When you index documents or receive notifications, Electric SQL pushes updates to your browser in real-time. The data flows like this:
+
+1. Backend writes data to PostgreSQL
+2. Electric SQL detects changes and streams them to the frontend
+3. PGlite (running in your browser) receives and stores the data locally in IndexedDB
+4. Your UI updates instantly without refreshing
+
+This means:
+
+- **Notifications appear instantly** - No need to refresh the page
+- **Document indexing progress updates live** - Watch your documents get processed
+- **Connector status syncs automatically** - See when connectors finish syncing
+- **Offline support** - PGlite caches data locally, so previously loaded data remains accessible
+
+## Docker Setup
+
+### All-in-One Quickstart
+
+The simplest way to run SurfSense with Electric SQL is using the all-in-one Docker image. This bundles everything into a single container:
+
+- PostgreSQL + pgvector (vector database)
+- Redis (task queue)
+- Electric SQL (real-time sync)
+- Backend API
+- Frontend
+
+```bash
+docker run -d \
+  -p 3000:3000 \
+  -p 8000:8000 \
+  -p 5133:5133 \
+  -v surfsense-data:/data \
+  --name surfsense \
+  ghcr.io/modsetter/surfsense:latest
+```
+
+**With custom Electric SQL credentials:**
+
+```bash
+docker run -d \
+  -p 3000:3000 \
+  -p 8000:8000 \
+  -p 5133:5133 \
+  -v surfsense-data:/data \
+  -e ELECTRIC_DB_USER=your_electric_user \
+  -e ELECTRIC_DB_PASSWORD=your_electric_password \
+  --name surfsense \
+  ghcr.io/modsetter/surfsense:latest
+```
+
+Access SurfSense at `http://localhost:3000`. Electric SQL is automatically configured and running on port 5133.
+
+### Docker Compose
+
+For more control over individual services, use Docker Compose.
+
+**Quickstart (all-in-one image):**
+
+```bash
+docker compose -f docker-compose.quickstart.yml up -d
+```
+
+**Standard setup (separate services):**
+
+The `docker-compose.yml` includes the Electric SQL service configuration:
+
+```yaml
+electric:
+  image: electricsql/electric:latest
+  ports:
+    - "${ELECTRIC_PORT:-5133}:3000"
+  environment:
+    - DATABASE_URL=${ELECTRIC_DATABASE_URL:-postgresql://${ELECTRIC_DB_USER:-electric}:${ELECTRIC_DB_PASSWORD:-electric_password}@${POSTGRES_HOST:-db}:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-surfsense}?sslmode=disable}
+    - ELECTRIC_INSECURE=true
+    - ELECTRIC_WRITE_TO_PG_MODE=direct
+  restart: unless-stopped
+  healthcheck:
+    test: ["CMD", "curl", "-f", "http://localhost:3000/v1/health"]
+    interval: 10s
+    timeout: 5s
+    retries: 5
+```
+
+No additional configuration is required - Electric SQL is pre-configured to work with the Docker PostgreSQL instance.
+
+## Manual Setup
+
+Follow the steps below based on your PostgreSQL setup.
+
+### Step 1: Configure Environment Variables
+
+Ensure your environment files are configured. If you haven't set up SurfSense yet, follow the [Manual Installation Guide](/docs/manual-installation) first.
+
+For Electric SQL, verify these variables are set:
+
+**Root `.env`:**
+
+```bash
+ELECTRIC_PORT=5133
+POSTGRES_HOST=host.docker.internal  # Use 'db' for Docker PostgreSQL instance
+ELECTRIC_DB_USER=electric
+ELECTRIC_DB_PASSWORD=electric_password
+NEXT_PUBLIC_ELECTRIC_URL=http://localhost:5133
+```
+
+**Frontend `.env` (`surfsense_web/.env`):**
+
+```bash
+NEXT_PUBLIC_ELECTRIC_URL=http://localhost:5133
+NEXT_PUBLIC_ELECTRIC_AUTH_MODE=insecure
+```
+
+---
+
+### Option A: Using Docker PostgreSQL
+
+If you're using the Docker-managed PostgreSQL instance, follow these steps:
+
+**1. Update environment variable:**
+
+In your root `.env` file, set:
+
+```bash
+POSTGRES_HOST=db
+```
+
+**2. Start PostgreSQL and Electric SQL:**
+
+```bash
+docker-compose up -d db electric
+```
+
+**3. Run database migration:**
+
+```bash
+cd surfsense_backend
+uv run alembic upgrade head
+```
+
+**4. Start the backend:**
+
+```bash
+uv run main.py
+```
+
+Electric SQL is now configured and connected to your Docker PostgreSQL database.
+
+---
+
+### Option B: Using Local PostgreSQL
+
+If you're using a local PostgreSQL installation, follow these steps:
+
+**1. Enable logical replication in PostgreSQL:**
+
+Open your `postgresql.conf` file using vim (or your preferred editor):
+
+```bash
+# Common locations:
+# macOS (Homebrew): /opt/homebrew/var/postgresql@15/postgresql.conf
+# Linux: /etc/postgresql/15/main/postgresql.conf
+# Windows: C:\Program Files\PostgreSQL\15\data\postgresql.conf
+
+sudo vim /path/to/postgresql.conf
+```
+
+Add the following settings:
+
+```ini
+# Enable logical replication (required for Electric SQL)
+wal_level = logical
+max_replication_slots = 10
+max_wal_senders = 10
+```
+
+After saving the changes (`:wq` in vim), restart your PostgreSQL server for the configuration to take effect.
+
+**2. Update environment variable:**
+
+In your root `.env` file, set:
+
+```bash
+POSTGRES_HOST=host.docker.internal
+```
+
+**3. Start Electric SQL:**
+
+```bash
+docker-compose up -d electric
+```
+
+**4. Run database migration:**
+
+```bash
+cd surfsense_backend
+uv run alembic upgrade head
+```
+
+**5. Start the backend:**
+
+```bash
+uv run main.py
+```
+
+Electric SQL is now configured and connected to your local PostgreSQL database.
+
+## Environment Variables Reference
+
+| Variable | Location | Description | Default |
+|----------|----------|-------------|---------|
+| `ELECTRIC_PORT` | Root `.env` | Port to expose Electric SQL | `5133` |
+| `POSTGRES_HOST` | Root `.env` | PostgreSQL host (`db` for Docker, `host.docker.internal` for local) | `host.docker.internal` |
+| `ELECTRIC_DB_USER` | Root `.env` | Database user for Electric | `electric` |
+| `ELECTRIC_DB_PASSWORD` | Root `.env` | Database password for Electric | `electric_password` |
+| `NEXT_PUBLIC_ELECTRIC_URL` | Frontend `.env` | Electric SQL server URL (PGlite connects to this) | `http://localhost:5133` |
+| `NEXT_PUBLIC_ELECTRIC_AUTH_MODE` | Frontend `.env` | Authentication mode (`insecure` for dev, `secure` for production) | `insecure` |
+## Verify Setup
+
+To verify Electric SQL is running correctly:
+
+```bash
+curl http://localhost:5133/v1/health
+```
+
+You should receive:
+
+```json
+{"status":"active"}
+```
+
+## Troubleshooting
+
+### Electric SQL Server Not Starting
+
+**Check PostgreSQL settings:**
+- Ensure `wal_level = logical` is set
+- Verify the Electric user has replication permissions
+- Check database connectivity from Electric container
+
+### Real-time Updates Not Working
+
+1. Open browser DevTools → Console
+2. Look for errors containing `[Electric]`
+3. Check Network tab for WebSocket connections to the Electric URL
+
+### Connection Refused Errors
+
+- Verify Electric SQL server is running: `docker ps | grep electric`
+- Check the `NEXT_PUBLIC_ELECTRIC_URL` matches your Electric server address
+- For Docker setups, ensure the frontend can reach the Electric container
+
+### Data Not Syncing
+
+- Check Electric SQL logs: `docker logs electric`
+- Verify PostgreSQL replication is working
+- Ensure the Electric user has proper table permissions
+
+### PGlite/IndexedDB Issues
+
+If data appears stale or corrupted in the browser:
+
+1. Open browser DevTools → Application → IndexedDB
+2. Delete databases starting with `surfsense-`
+3. Refresh the page - PGlite will recreate the local database and resync

surfsense_web/content/docs/how-to/meta.json

@@ -0,0 +1,5 @@
+{
+	"title": "How to",
+	"pages": ["electric-sql"],
+	"defaultOpen": false
+}

surfsense_web/content/docs/meta.json

@@ -8,6 +8,7 @@
 		"installation",
 		"docker-installation",
 		"manual-installation",
-		"connectors"
+		"connectors",
+		"how-to"
 	]
 }

surfsense_web/contracts/enums/connector.ts

@@ -1,4 +1,5 @@
 export enum EnumConnectorName {
+	SERPER_API = "SERPER_API",
 	TAVILY_API = "TAVILY_API",
 	SEARXNG_API = "SEARXNG_API",
 	LINKUP_API = "LINKUP_API",
@@ -22,4 +23,5 @@ export enum EnumConnectorName {
 	WEBCRAWLER_CONNECTOR = "WEBCRAWLER_CONNECTOR",
 	YOUTUBE_CONNECTOR = "YOUTUBE_CONNECTOR",
 	CIRCLEBACK_CONNECTOR = "CIRCLEBACK_CONNECTOR",
+	MCP_CONNECTOR = "MCP_CONNECTOR",
 }