fix: Fixing requirements.txt inconsistencies

Dockerfile

@@ -6,6 +6,7 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ffmpeg \
     libsndfile1 \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt .

alembic.ini

@@ -0,0 +1,149 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+# Or organize into date-based subdirectories (requires recursive_version_locations = true)
+# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the tzdata library which can be installed by adding
+# `alembic[tz]` to the pip requirements.
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
+# hooks = ruff
+# ruff.type = module
+# ruff.module = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Alternatively, use the exec runner to execute a binary found on your PATH
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,130 @@
+import os
+import re
+import sys
+import urllib.parse
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config, pool
+from alembic import context
+
+# Ensure both src and project root / app root are on sys.path
+_here = os.path.dirname(os.path.abspath(__file__))
+_parent = os.path.abspath(os.path.join(_here, ".."))
+_grandparent = os.path.abspath(os.path.join(_parent, ".."))
+for _p in (_grandparent, _parent):
+    if _p and _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from src.config import settings
+from src.db_models import Base
+
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Set target metadata for autogenerate support
+target_metadata = Base.metadata
+
+
+def sanitize_db_url(url: str) -> str:
+    """Sanitize database URL by stripping pgbouncer flags and URL-encoding password special chars."""
+    if not url or "://" not in url:
+        return url
+    if "pgbouncer=true" in url:
+        url = url.replace("?pgbouncer=true&", "?").replace("&pgbouncer=true", "").replace("?pgbouncer=true", "")
+    
+    # URL-encode un-encoded special characters in password
+    pattern = r"^(?P<scheme>[^:]+://)(?P<user>[^:]+):(?P<password>.+)@(?P<host>[^@:]+:\d+/.+)$"
+    m = re.match(pattern, url)
+    if m:
+        scheme = m.group("scheme")
+        user = m.group("user")
+        password = m.group("password")
+        host = m.group("host")
+        if "%" not in password:
+            password = urllib.parse.quote(password, safe="")
+        return f"{scheme}{user}:{password}@{host}"
+    return url
+
+
+# Dynamically inject DATABASE_URL from config.env / settings
+db_url = sanitize_db_url(settings.database_url or os.getenv("DATABASE_URL", ""))
+
+if db_url:
+    # Escape % as %% for configparser interpolation
+    config.set_main_option("sqlalchemy.url", db_url.replace("%", "%%"))
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    context.configure(
+        url=db_url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        compare_type=my_compare_type,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def my_compare_type(context, inspected_column, metadata_column, inspected_type, metadata_type):
+    # Ignore equivalent string/text type differences between Supabase TEXT and SQLAlchemy String
+    ins_type = type(inspected_type).__name__.upper()
+    meta_type = type(metadata_type).__name__.upper()
+    if ins_type in ("TEXT", "VARCHAR", "STRING") and meta_type in ("TEXT", "VARCHAR", "STRING"):
+        return False
+    return None
+
+
+def include_object(object, name, type_, reflected, compare_to):
+    """
+    Only report table-level additions and removals.
+    Ignore column, index, FK, and constraint differences on existing tables
+    to avoid noise from schema drift between Supabase native schema and ORM models.
+    """
+    # Always include tables (so new/removed tables are detected)
+    if type_ == "table":
+        return True
+    # Skip everything else on tables that already exist in the DB
+    return False
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    if not db_url:
+        return
+
+    configuration = config.get_section(config.config_ini_section, {})
+    if db_url:
+        configuration["sqlalchemy.url"] = db_url
+
+    connectable = engine_from_config(
+        configuration,
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            compare_type=False,
+            compare_nullable=False,
+            include_object=include_object,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,33 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+try:
+    import pgvector
+except ImportError:
+    pass
+${imports if imports else ""}
+
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

alembic/versions/046aabbd3fee_removing_refresh_tokens_table.py

@@ -0,0 +1,47 @@
+"""Removing Refresh Tokens Table
+
+Revision ID: 046aabbd3fee
+Revises: 0f6538b84133
+Create Date: 2026-08-15 06:27:29.825530
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+try:
+    import pgvector
+except ImportError:
+    pass
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = '046aabbd3fee'
+down_revision: Union[str, Sequence[str], None] = '0f6538b84133'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('refresh_tokens')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('refresh_tokens',
+    sa.Column('id', sa.UUID(), server_default=sa.text('gen_random_uuid()'), autoincrement=False, nullable=False),
+    sa.Column('user_id', sa.UUID(), autoincrement=False, nullable=False),
+    sa.Column('token_hash', sa.TEXT(), autoincrement=False, nullable=False),
+    sa.Column('expires_at', postgresql.TIMESTAMP(timezone=True), autoincrement=False, nullable=False),
+    sa.Column('revoked', sa.BOOLEAN(), server_default=sa.text('false'), autoincrement=False, nullable=False),
+    sa.Column('created_at', postgresql.TIMESTAMP(timezone=True), server_default=sa.text('now()'), autoincrement=False, nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['profiles.id'], name=op.f('refresh_tokens_user_id_fkey'), ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id', name=op.f('refresh_tokens_pkey')),
+    sa.UniqueConstraint('token_hash', name=op.f('refresh_tokens_token_hash_key'), postgresql_include=[], postgresql_nulls_not_distinct=False)
+    )
+    # ### end Alembic commands ###

alembic/versions/0f6538b84133_initial_supabase_schema.py

@@ -0,0 +1,346 @@
+"""Initial Supabase schema
+
+Revision ID: 0f6538b84133
+Revises: 
+Create Date: 2026-08-09 22:55:09.716607
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+import pgvector
+
+
+# revision identifiers, used by Alembic.
+revision: str = '0f6538b84133'
+down_revision: Union[str, Sequence[str], None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('chat_messages', 'role',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               nullable=True)
+    op.alter_column('chat_messages', 'content',
+               existing_type=sa.TEXT(),
+               nullable=True)
+    op.alter_column('chat_messages', 'retrieved_chunk_ids',
+               existing_type=postgresql.ARRAY(sa.UUID()),
+               type_=postgresql.JSONB(astext_type=sa.Text()),
+               existing_nullable=True)
+    op.drop_index(op.f('idx_chat_messages_session_id'), table_name='chat_messages')
+    op.alter_column('chat_sessions', 'material_id',
+               existing_type=sa.UUID(),
+               nullable=False)
+    op.alter_column('chat_sessions', 'title',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.drop_index(op.f('idx_chat_sessions_material_id'), table_name='chat_sessions')
+    op.drop_index(op.f('idx_chat_sessions_user_id'), table_name='chat_sessions')
+    op.drop_constraint(op.f('chat_sessions_material_id_fkey'), 'chat_sessions', type_='foreignkey')
+    op.create_foreign_key(None, 'chat_sessions', 'materials', ['material_id'], ['id'], ondelete='CASCADE')
+    op.drop_index(op.f('idx_material_chunks_material_id'), table_name='material_chunks')
+    op.drop_constraint(op.f('material_chunks_material_id_chunk_index_key'), 'material_chunks', type_='unique')
+    op.alter_column('material_embeddings', 'embedding',
+               existing_type=pgvector.sqlalchemy.vector.VECTOR(dim=384),
+               nullable=True)
+    op.drop_index(op.f('idx_embeddings_chunk_id'), table_name='material_embeddings')
+    op.drop_index(op.f('idx_embeddings_material_id'), table_name='material_embeddings')
+    op.drop_index(op.f('idx_embeddings_vector'), table_name='material_embeddings', postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
+    op.alter_column('materials', 'source_type',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False)
+    op.alter_column('materials', 'title',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False)
+    op.alter_column('materials', 'file_path',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('materials', 'url',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('materials', 'status',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'pending'::text"))
+    op.alter_column('materials', 'error_message',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('materials', 'vector_store_path',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('materials', 'title_normalized',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True,
+               existing_server_default=sa.Computed('normalize_arabic(lower(title))', persisted=True))
+    op.drop_index(op.f('idx_materials_status'), table_name='materials')
+    op.drop_index(op.f('idx_materials_title_normalized_trgm'), table_name='materials', postgresql_using='gin')
+    op.drop_index(op.f('idx_materials_title_trgm'), table_name='materials', postgresql_using='gin')
+    op.drop_index(op.f('idx_materials_user_id'), table_name='materials')
+    op.drop_constraint(op.f('materials_user_id_title_key'), 'materials', type_='unique')
+    op.alter_column('profiles', 'email',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'display_name',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'avatar_url',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'last_request_date',
+               existing_type=sa.DATE(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'theme',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'system'::text"))
+    op.drop_constraint(op.f('profiles_id_fkey'), 'profiles', type_='foreignkey')
+    op.alter_column('quiz_attempts', 'score',
+               existing_type=sa.INTEGER(),
+               nullable=True)
+    op.alter_column('quiz_attempts', 'total',
+               existing_type=sa.INTEGER(),
+               nullable=True)
+    op.alter_column('quiz_attempts', 'results',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               nullable=True)
+    op.drop_index(op.f('idx_quiz_attempts_quiz_id'), table_name='quiz_attempts')
+    op.alter_column('quizzes', 'source_type',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               nullable=True)
+    op.alter_column('quizzes', 'difficulty',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               nullable=True)
+    op.alter_column('quizzes', 'mcq_count',
+               existing_type=sa.INTEGER(),
+               nullable=True)
+    op.alter_column('quizzes', 'tf_count',
+               existing_type=sa.INTEGER(),
+               nullable=True)
+    op.alter_column('quizzes', 'quiz_data',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               nullable=True)
+    op.alter_column('quizzes', 'status',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'completed'::text"))
+    op.alter_column('quizzes', 'model_name',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('quizzes', 'error_message',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.drop_index(op.f('idx_quizzes_material_id'), table_name='quizzes')
+    op.drop_index(op.f('idx_quizzes_user_id'), table_name='quizzes')
+    op.drop_constraint(op.f('quizzes_material_id_fkey'), 'quizzes', type_='foreignkey')
+    op.create_foreign_key(None, 'quizzes', 'materials', ['material_id'], ['id'], ondelete='CASCADE')
+    op.alter_column('refresh_tokens', 'token_hash',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False)
+    op.drop_index(op.f('idx_refresh_tokens_token_hash'), table_name='refresh_tokens')
+    op.drop_index(op.f('idx_refresh_tokens_user_id'), table_name='refresh_tokens')
+    op.alter_column('summaries', 'status',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'completed'::text"))
+    op.alter_column('summaries', 'model_name',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.alter_column('summaries', 'error_message',
+               existing_type=sa.TEXT(),
+               type_=sa.String(),
+               existing_nullable=True)
+    op.drop_index(op.f('idx_summaries_material_id'), table_name='summaries')
+    op.drop_constraint(op.f('summaries_material_id_key'), 'summaries', type_='unique')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_unique_constraint(op.f('summaries_material_id_key'), 'summaries', ['material_id'], postgresql_nulls_not_distinct=False)
+    op.create_index(op.f('idx_summaries_material_id'), 'summaries', ['material_id'], unique=False)
+    op.alter_column('summaries', 'error_message',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('summaries', 'model_name',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('summaries', 'status',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'completed'::text"))
+    op.create_index(op.f('idx_refresh_tokens_user_id'), 'refresh_tokens', ['user_id'], unique=False)
+    op.create_index(op.f('idx_refresh_tokens_token_hash'), 'refresh_tokens', ['token_hash'], unique=False)
+    op.alter_column('refresh_tokens', 'token_hash',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False)
+    op.drop_constraint(None, 'quizzes', type_='foreignkey')
+    op.create_foreign_key(op.f('quizzes_material_id_fkey'), 'quizzes', 'materials', ['material_id'], ['id'], ondelete='SET NULL')
+    op.create_index(op.f('idx_quizzes_user_id'), 'quizzes', ['user_id'], unique=False)
+    op.create_index(op.f('idx_quizzes_material_id'), 'quizzes', ['material_id'], unique=False)
+    op.alter_column('quizzes', 'error_message',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('quizzes', 'model_name',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('quizzes', 'status',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'completed'::text"))
+    op.alter_column('quizzes', 'quiz_data',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               nullable=False)
+    op.alter_column('quizzes', 'tf_count',
+               existing_type=sa.INTEGER(),
+               nullable=False)
+    op.alter_column('quizzes', 'mcq_count',
+               existing_type=sa.INTEGER(),
+               nullable=False)
+    op.alter_column('quizzes', 'difficulty',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               nullable=False)
+    op.alter_column('quizzes', 'source_type',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               nullable=False)
+    op.create_index(op.f('idx_quiz_attempts_quiz_id'), 'quiz_attempts', ['quiz_id'], unique=False)
+    op.alter_column('quiz_attempts', 'results',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               nullable=False)
+    op.alter_column('quiz_attempts', 'total',
+               existing_type=sa.INTEGER(),
+               nullable=False)
+    op.alter_column('quiz_attempts', 'score',
+               existing_type=sa.INTEGER(),
+               nullable=False)
+    op.create_foreign_key(op.f('profiles_id_fkey'), 'profiles', 'users', ['id'], ['id'], referent_schema='auth', ondelete='CASCADE')
+    op.alter_column('profiles', 'theme',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'system'::text"))
+    op.alter_column('profiles', 'last_request_date',
+               existing_type=sa.String(),
+               type_=sa.DATE(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'avatar_url',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'display_name',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('profiles', 'email',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.create_unique_constraint(op.f('materials_user_id_title_key'), 'materials', ['user_id', 'title'], postgresql_nulls_not_distinct=False)
+    op.create_index(op.f('idx_materials_user_id'), 'materials', ['user_id'], unique=False)
+    op.create_index(op.f('idx_materials_title_trgm'), 'materials', ['title'], unique=False, postgresql_using='gin')
+    op.create_index(op.f('idx_materials_title_normalized_trgm'), 'materials', ['title_normalized'], unique=False, postgresql_using='gin')
+    op.create_index(op.f('idx_materials_status'), 'materials', ['status'], unique=False)
+    op.alter_column('materials', 'title_normalized',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True,
+               existing_server_default=sa.Computed('normalize_arabic(lower(title))', persisted=True))
+    op.alter_column('materials', 'vector_store_path',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('materials', 'error_message',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('materials', 'status',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False,
+               existing_server_default=sa.text("'pending'::text"))
+    op.alter_column('materials', 'url',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('materials', 'file_path',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('materials', 'title',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False)
+    op.alter_column('materials', 'source_type',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=False)
+    op.create_index(op.f('idx_embeddings_vector'), 'material_embeddings', ['embedding'], unique=False, postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
+    op.create_index(op.f('idx_embeddings_material_id'), 'material_embeddings', ['material_id'], unique=False)
+    op.create_index(op.f('idx_embeddings_chunk_id'), 'material_embeddings', ['chunk_id'], unique=False)
+    op.alter_column('material_embeddings', 'embedding',
+               existing_type=pgvector.sqlalchemy.vector.VECTOR(dim=384),
+               nullable=False)
+    op.create_unique_constraint(op.f('material_chunks_material_id_chunk_index_key'), 'material_chunks', ['material_id', 'chunk_index'], postgresql_nulls_not_distinct=False)
+    op.create_index(op.f('idx_material_chunks_material_id'), 'material_chunks', ['material_id'], unique=False)
+    op.drop_constraint(None, 'chat_sessions', type_='foreignkey')
+    op.create_foreign_key(op.f('chat_sessions_material_id_fkey'), 'chat_sessions', 'materials', ['material_id'], ['id'], ondelete='SET NULL')
+    op.create_index(op.f('idx_chat_sessions_user_id'), 'chat_sessions', ['user_id'], unique=False)
+    op.create_index(op.f('idx_chat_sessions_material_id'), 'chat_sessions', ['material_id'], unique=False)
+    op.alter_column('chat_sessions', 'title',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               existing_nullable=True)
+    op.alter_column('chat_sessions', 'material_id',
+               existing_type=sa.UUID(),
+               nullable=True)
+    op.create_index(op.f('idx_chat_messages_session_id'), 'chat_messages', ['session_id'], unique=False)
+    op.alter_column('chat_messages', 'retrieved_chunk_ids',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               type_=postgresql.ARRAY(sa.UUID()),
+               existing_nullable=True)
+    op.alter_column('chat_messages', 'content',
+               existing_type=sa.TEXT(),
+               nullable=False)
+    op.alter_column('chat_messages', 'role',
+               existing_type=sa.String(),
+               type_=sa.TEXT(),
+               nullable=False)
+    # ### end Alembic commands ###

main.py

@@ -28,10 +28,33 @@ from src.config import settings
 async def lifespan(app: FastAPI):
     # Run pending Alembic database migrations automatically on server startup
     try:
-        import subprocess
-        logger.info("Running database migrations via Alembic...")
-        subprocess.run(["alembic", "upgrade", "head"], check=True)
-        logger.info("Database migrations completed successfully.")
+        db_url = settings.database_url or os.getenv("DATABASE_URL", "")
+        if not db_url:
+            logger.info("DATABASE_URL not configured; skipping automatic Alembic migrations.")
+        else:
+            from alembic.config import Config
+            from alembic import command
+
+            candidate_ini = None
+            for p in [
+                os.path.join(current_dir, "alembic.ini"),
+                os.path.join(parent_dir, "alembic.ini"),
+                os.path.abspath("alembic.ini"),
+            ]:
+                if os.path.isfile(p):
+                    candidate_ini = p
+                    break
+
+            if candidate_ini:
+                logger.info(f"Running database migrations via Alembic ({candidate_ini})...")
+                alembic_cfg = Config(candidate_ini)
+                script_dir = os.path.join(os.path.dirname(candidate_ini), "alembic")
+                if os.path.isdir(script_dir):
+                    alembic_cfg.set_main_option("script_location", script_dir)
+                command.upgrade(alembic_cfg, "head")
+                logger.info("Database migrations completed successfully.")
+            else:
+                logger.warning("alembic.ini not found; skipping database migrations.")
     except Exception as e:
         logger.warning(f"Database migration step failed or skipped: {e}")
 

rag/rag.py

@@ -56,6 +56,10 @@ from .schemas import EmbeddingJob
 
 @lru_cache
 def get_embedder():
+    try:
+        import sentence_transformers
+    except Exception as exc:
+        logger.error(f"Failed to import sentence_transformers directly: {exc}", exc_info=True)
     return HuggingFaceEmbeddings(
         model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
         model_kwargs={"device": "cpu"},

requirements.txt

@@ -1,6 +1,7 @@
 --extra-index-url https://download.pytorch.org/whl/cpu
 torch
 torchvision
+torchaudio
 
 arxiv==2.2.0
 wikipedia==1.4.0
@@ -16,9 +17,16 @@ mistralai
 langchain-openai
 langchain-huggingface
 langchain-text-splitters
+langsmith
 python-dotenv
-sentence-transformers
-numpy
+
+# ── Retrieval & Search ────────────────────────────────────
+sentence-transformers>=3.0.0
+rank-bm25>=0.2.2
+
+# ── Binary Compatibility (NumPy & PyArrow) ────────────────
+numpy>=1.26.4,<2.0.0
+pyarrow>=14.0.0,<18.0.0
 
 pdfplumber==0.11.4
 unstructured==0.18.15
@@ -35,9 +43,11 @@ passlib[bcrypt]>=1.7.4
 supabase
 redis>=5.0.0
 transformers
+einops
 sacremoses
 sentencepiece
 omegaconf
+onnxruntime>=1.17.0
 
 # ── ASR Models ──────────────────────────────────────────
 nemo_toolkit[asr]