feat: revamped project structure

Dockerfile

@@ -1,19 +1,7 @@
-# Use Python 3.10 slim (Standard for HF Spaces)
 FROM python:3.11-slim
 
-WORKDIR /app
-
-# 1. Install system dependencies + Redis Server
-USER root
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    redis-server \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN useradd -m -u 1000 user && \
-    mkdir -p /var/run/redis /var/log/redis && \
-    chown -R user:user /var/run/redis /var/log/redis /var/lib/redis
-
+# Create a non-root user with UID 1000 as required by HF Spaces
+RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
     PATH=/home/user/.local/bin:$PATH \
@@ -21,20 +9,20 @@ ENV HOME=/home/user \
     PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1
 
-# 3. Install Dependencies
-# Copy only requirements first to leverage Docker cache
+WORKDIR /app
+
+# Install Python dependencies
 COPY --chown=user requirements.txt .
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
-# 4. Copy Code & Model
-# We copy everything in the current directory (src, onnx_model_optimized, alembic)
-COPY --chown=user . .
+RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
 
-# 5. Make start script executable
-RUN chmod +x start.sh
+# Copy all application files into the container
+COPY --chown=user . .
 
-# 6. Expose the mandatory Hugging Face port
+# Expose the mandatory Hugging Face port
 EXPOSE 7860
 
-# 7. Run the start script
-CMD ["./start.sh"]
+# Run FastAPI directly in the foreground
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -8,5 +8,5 @@ app_port: 7860
 pinned: false
 ---
 
-# SentimentScope Backend
-This is the private backend worker running FastAPI + Celery + ONNX Quantized Model.
+# Joule Dynamics RAG Demo
+Backend API for the Amara Home & Kitchen RAG chatbot.

alembic.ini

@@ -1,147 +0,0 @@
-# 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
-
-# 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 python>=3.9 or backports.zoneinfo library and tzdata library.
-# Any required deps can 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 =
-
-
-[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

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

alembic/env.py

@@ -1,91 +0,0 @@
-from logging.config import fileConfig
-import asyncio
-
-
-from sqlalchemy import engine_from_config
-from sqlalchemy import pool
-from sqlalchemy.engine import Connection
-from sqlalchemy.ext.asyncio import create_async_engine
-
-from alembic import context
-
-from src.app.db.base import Base
-from src.app.config import settings
-from src.app import models
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config # type: ignore[attr-defined]
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-target_metadata = Base.metadata
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
-
-    """
-    url = str(settings.DATABASE_URL)
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    ) # type: ignore[attr-defined]
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def do_run_migrations(connection: Connection) -> None:
-    context.configure(
-        connection=connection, target_metadata=target_metadata
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-async def run_migrations_online() -> None:
-    """Run migrations in 'online' mode.
-
-    In this scenario we need to create an Engine
-    and associate a connection with the context.
-
-    """
-    
-
-    connectable = create_async_engine(
-        str(settings.DATABASE_URL),
-        poolclass=pool.NullPool,
-        connect_args={"command_timeout": 300},
-    )
-
-    async with connectable.connect() as connection:
-        await connection.run_sync(do_run_migrations)
-    await connectable.dispose()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    asyncio.run(run_migrations_online())

alembic/script.py.mako

@@ -1,28 +0,0 @@
-"""${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
-${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/0724098f2d79_add_embeddings_column_with_server_.py

@@ -1,34 +0,0 @@
-"""add embeddings column with server default
-
-Revision ID: 0724098f2d79
-Revises: 2cfae3938d63
-Create Date: 2025-12-03 10:08:06.156818
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '0724098f2d79'
-down_revision: Union[str, Sequence[str], None] = '2cfae3938d63'
-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.add_column('chats', sa.Column('embeddings_status', sa.String(length=30), server_default='pending', nullable=False))
-    op.create_index(op.f('ix_chats_embeddings_status'), 'chats', ['embeddings_status'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_chats_embeddings_status'), table_name='chats')
-    op.drop_column('chats', 'embeddings_status')
-    # ### end Alembic commands ###

alembic/versions/293bf8cae101_add_conversation_history_table.py

@@ -1,50 +0,0 @@
-"""add conversation history table
-
-Revision ID: 293bf8cae101
-Revises: 3bdda54c971f
-Create Date: 2025-11-18 02:56:39.769901
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '293bf8cae101'
-down_revision: Union[str, Sequence[str], None] = '3bdda54c971f'
-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.create_table('conversation_history',
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('chat_id', sa.Integer(), nullable=False),
-    sa.Column('role', sa.String(length=20), nullable=False),
-    sa.Column('content', sa.Text(), nullable=False),
-    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
-    sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_conversation_history_chat_id'), 'conversation_history', ['chat_id'], unique=False)
-    # op.drop_index(op.f('embeddings_chat_id_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_chat_source_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_embedding_ivfflat'), table_name='embeddings', postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('ix_embeddings_chat_id'), 'embeddings', ['chat_id'], unique=False)
-    # # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    # op.drop_index(op.f('ix_embeddings_chat_id'), table_name='embeddings')
-    # op.create_index(op.f('embeddings_embedding_ivfflat'), 'embeddings', ['embedding'], unique=False, postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('embeddings_chat_source_idx'), 'embeddings', ['chat_id', 'source_table', 'source_id'], unique=False)
-    # op.create_index(op.f('embeddings_chat_id_idx'), 'embeddings', ['chat_id'], unique=False)
-    # op.drop_index(op.f('ix_conversation_history_chat_id'), table_name='conversation_history')
-    op.drop_table('conversation_history')
-    # ### end Alembic commands ###

alembic/versions/2bae362756b9_version_9.py

@@ -1,58 +0,0 @@
-"""Version 9
-
-Revision ID: 2bae362756b9
-Revises: 50eb9bd827e5
-Create Date: 2025-11-01 08:15:21.483742
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '2bae362756b9'
-down_revision: Union[str, Sequence[str], None] = '50eb9bd827e5'
-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.create_index(op.f('ix_chats_created_at'), 'chats', ['created_at'], unique=False)
-    op.create_index(op.f('ix_chats_sentiment_status'), 'chats', ['sentiment_status'], unique=False)
-    op.create_index(op.f('ix_message_sentiments_analysis_timestamp'), 'message_sentiments', ['analysis_timestamp'], unique=False)
-    op.create_index(op.f('ix_messages_chat_id'), 'messages', ['chat_id'], unique=False)
-    op.create_index(op.f('ix_messages_participant_id'), 'messages', ['participant_id'], unique=False)
-    op.drop_constraint(op.f('messages_participant_id_fkey'), 'messages', type_='foreignkey')
-    op.create_foreign_key(None, 'messages', 'participants', ['participant_id'], ['id'], ondelete='SET NULL')
-    op.create_index(op.f('ix_participants_chat_id'), 'participants', ['chat_id'], unique=False)
-    op.create_index(op.f('ix_participants_created_at'), 'participants', ['created_at'], unique=False)
-    op.create_index(op.f('ix_segment_sentiments_analysis_timestamp'), 'segment_sentiments', ['analysis_timestamp'], unique=False)
-    op.create_index(op.f('ix_segments_sender_sender_id'), 'segments_sender', ['sender_id'], unique=False)
-    op.create_index(op.f('ix_segments_sender_time_segment_id'), 'segments_sender', ['time_segment_id'], unique=False)
-    op.create_index(op.f('ix_segments_time_chat_id'), 'segments_time', ['chat_id'], unique=False)
-    op.create_index(op.f('ix_segments_time_start_time'), 'segments_time', ['start_time'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_segments_time_start_time'), table_name='segments_time')
-    op.drop_index(op.f('ix_segments_time_chat_id'), table_name='segments_time')
-    op.drop_index(op.f('ix_segments_sender_time_segment_id'), table_name='segments_sender')
-    op.drop_index(op.f('ix_segments_sender_sender_id'), table_name='segments_sender')
-    op.drop_index(op.f('ix_segment_sentiments_analysis_timestamp'), table_name='segment_sentiments')
-    op.drop_index(op.f('ix_participants_created_at'), table_name='participants')
-    op.drop_index(op.f('ix_participants_chat_id'), table_name='participants')
-    op.drop_constraint(None, 'messages', type_='foreignkey')
-    op.create_foreign_key(op.f('messages_participant_id_fkey'), 'messages', 'participants', ['participant_id'], ['id'])
-    op.drop_index(op.f('ix_messages_participant_id'), table_name='messages')
-    op.drop_index(op.f('ix_messages_chat_id'), table_name='messages')
-    op.drop_index(op.f('ix_message_sentiments_analysis_timestamp'), table_name='message_sentiments')
-    op.drop_index(op.f('ix_chats_sentiment_status'), table_name='chats')
-    op.drop_index(op.f('ix_chats_created_at'), table_name='chats')
-    # ### end Alembic commands ###

alembic/versions/2cfae3938d63_change_embeddings_table_structure.py

@@ -1,32 +0,0 @@
-"""change embeddings table structure
-
-Revision ID: 2cfae3938d63
-Revises: af5827742674
-Create Date: 2025-11-28 18:14:02.462140
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '2cfae3938d63'
-down_revision: Union[str, Sequence[str], None] = 'af5827742674'
-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! ###
-    pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/3bdda54c971f_update_embedding_dimension_to_3072.py

@@ -1,39 +0,0 @@
-"""update_embedding_dimension_to_3072
-
-Revision ID: 3bdda54c971f
-Revises: e817f10d0cc8
-Create Date: 2025-11-12 14:58:09.216085
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '3bdda54c971f'
-down_revision: Union[str, Sequence[str], None] = 'e817f10d0cc8'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-def upgrade() -> None:
-    # ### commands auto-generated by Alembic - manually adjusted ###
-    print("Altering embedding column type to vector(3072)...")
-    
-    # This command changes the database column to accept the new dimension.
-    op.execute("ALTER TABLE public.embeddings ALTER COLUMN embedding TYPE vector(1536);")
-    
-    print("Done.")
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto-generated by Alembic - manually adjusted ###
-    print("Reverting embedding column type to vector(1536)...")
-    
-    # This reverts the change if you ever need to.
-    op.execute("ALTER TABLE public.embeddings ALTER COLUMN embedding TYPE vector(1536);")
-    
-    print("Done.")
-    # ### end Alembic commands ###

alembic/versions/4de3dfd809bd_add_sources_to_conversation_history.py

@@ -1,40 +0,0 @@
-"""add sources to conversation history
-
-Revision ID: 4de3dfd809bd
-Revises: 293bf8cae101
-Create Date: 2025-11-19 02:53:46.860280
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '4de3dfd809bd'
-down_revision: Union[str, Sequence[str], None] = '293bf8cae101'
-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.add_column('conversation_history', sa.Column('sources', sa.JSON(), nullable=True))
-    # op.drop_index(op.f('embeddings_chat_id_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_chat_source_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_embedding_ivfflat'), table_name='embeddings', postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('ix_embeddings_chat_id'), 'embeddings', ['chat_id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    # op.drop_index(op.f('ix_embeddings_chat_id'), table_name='embeddings')
-    # op.create_index(op.f('embeddings_embedding_ivfflat'), 'embeddings', ['embedding'], unique=False, postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('embeddings_chat_source_idx'), 'embeddings', ['chat_id', 'source_table', 'source_id'], unique=False)
-    # op.create_index(op.f('embeddings_chat_id_idx'), 'embeddings', ['chat_id'], unique=False)
-    op.drop_column('conversation_history', 'sources')
-    # ### end Alembic commands ###

alembic/versions/50eb9bd827e5_version_8.py

@@ -1,32 +0,0 @@
-"""Version 8
-
-Revision ID: 50eb9bd827e5
-Revises: bbbad8eb92e1
-Create Date: 2025-10-18 02:49:04.517995
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '50eb9bd827e5'
-down_revision: Union[str, Sequence[str], None] = 'bbbad8eb92e1'
-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.add_column('chats', sa.Column('cancel_requested', sa.Boolean(), nullable=True))
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('chats', 'cancel_requested')
-    # ### end Alembic commands ###

alembic/versions/51088f15a504_version_5.py

@@ -1,32 +0,0 @@
-"""version 5
-
-Revision ID: 51088f15a504
-Revises: 576915939aff
-Create Date: 2025-10-12 02:43:12.573367
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '51088f15a504'
-down_revision: Union[str, Sequence[str], None] = '576915939aff'
-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.add_column('chats', sa.Column('sentiment_status', sa.String(length=30), nullable=False))
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('chats', 'sentiment_status')
-    # ### end Alembic commands ###

alembic/versions/576915939aff_version_4.py

@@ -1,109 +0,0 @@
-"""version 4
-
-Revision ID: 576915939aff
-Revises: 9c071425ee4a
-Create Date: 2025-10-10 17:57:04.404537
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = '576915939aff'
-down_revision: Union[str, Sequence[str], None] = '9c071425ee4a'
-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.create_table('segments_time',
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('chat_id', sa.Integer(), nullable=False),
-    sa.Column('start_time', sa.DateTime(), nullable=False),
-    sa.Column('end_time', sa.DateTime(), nullable=False),
-    sa.Column('duration_minutes', sa.Float(), nullable=False),
-    sa.Column('message_count', sa.Integer(), nullable=False),
-    sa.Column('summary', sa.Text(), nullable=True),
-    sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_table('segments_sender',
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('time_segment_id', sa.Integer(), nullable=False),
-    sa.Column('sender_id', sa.Integer(), nullable=False),
-    sa.Column('message_count', sa.Integer(), nullable=False),
-    sa.Column('combined_text', sa.Text(), nullable=False),
-    sa.ForeignKeyConstraint(['sender_id'], ['participants.id'], ondelete='CASCADE'),
-    sa.ForeignKeyConstraint(['time_segment_id'], ['segments_time.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_table('message_sentiments',
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('message_id', sa.Integer(), nullable=False),
-    sa.Column('overall_label', sa.String(length=50), nullable=False),
-    sa.Column('score_positive', sa.Float(), nullable=False),
-    sa.Column('score_negative', sa.Float(), nullable=False),
-    sa.Column('score_neutral', sa.Float(), nullable=False),
-    sa.Column('sentences_summary', sa.JSON(), nullable=True),
-    sa.Column('opinions', sa.JSON(), nullable=True),
-    sa.Column('api_version', sa.String(length=50), nullable=True),
-    sa.Column('analysis_timestamp', sa.DateTime(timezone=True), nullable=False),
-    sa.Column('error_code', sa.String(length=100), nullable=True),
-    sa.Column('error_message', sa.Text(), nullable=True),
-    sa.ForeignKeyConstraint(['message_id'], ['messages.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_message_sentiments_message_id'), 'message_sentiments', ['message_id'], unique=True)
-    op.create_table('segment_sentiments',
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('sender_segment_id', sa.Integer(), nullable=False),
-    sa.Column('overall_label', sa.String(length=50), nullable=False),
-    sa.Column('score_positive', sa.Float(), nullable=False),
-    sa.Column('score_negative', sa.Float(), nullable=False),
-    sa.Column('score_neutral', sa.Float(), nullable=False),
-    sa.Column('sentences_summary', sa.JSON(), nullable=True),
-    sa.Column('opinions', sa.JSON(), nullable=True),
-    sa.Column('api_version', sa.String(length=50), nullable=True),
-    sa.Column('analysis_timestamp', sa.DateTime(timezone=True), nullable=False),
-    sa.Column('error_code', sa.String(length=100), nullable=True),
-    sa.Column('error_message', sa.Text(), nullable=True),
-    sa.ForeignKeyConstraint(['sender_segment_id'], ['segments_sender.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_segment_sentiments_sender_segment_id'), 'segment_sentiments', ['sender_segment_id'], unique=True)
-    op.drop_table('sentiments')
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('sentiments',
-    sa.Column('id', sa.INTEGER(), autoincrement=True, nullable=False),
-    sa.Column('message_id', sa.INTEGER(), autoincrement=False, nullable=False),
-    sa.Column('overall_label', sa.VARCHAR(length=50), autoincrement=False, nullable=False),
-    sa.Column('score_positive', sa.DOUBLE_PRECISION(precision=53), autoincrement=False, nullable=False),
-    sa.Column('score_negative', sa.DOUBLE_PRECISION(precision=53), autoincrement=False, nullable=False),
-    sa.Column('score_neutral', sa.DOUBLE_PRECISION(precision=53), autoincrement=False, nullable=False),
-    sa.Column('sentences_summary', postgresql.JSON(astext_type=sa.Text()), autoincrement=False, nullable=True),
-    sa.Column('opinions', postgresql.JSON(astext_type=sa.Text()), autoincrement=False, nullable=True),
-    sa.Column('api_version', sa.VARCHAR(length=50), autoincrement=False, nullable=True),
-    sa.Column('analysis_timestamp', postgresql.TIMESTAMP(timezone=True), autoincrement=False, nullable=False),
-    sa.Column('error_code', sa.VARCHAR(length=100), autoincrement=False, nullable=True),
-    sa.Column('error_message', sa.TEXT(), autoincrement=False, nullable=True),
-    sa.ForeignKeyConstraint(['message_id'], ['messages.id'], name=op.f('sentiments_message_id_fkey'), ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id', name=op.f('sentiments_pkey')),
-    sa.UniqueConstraint('message_id', name=op.f('sentiments_message_id_key'), postgresql_include=[], postgresql_nulls_not_distinct=False)
-    )
-    op.drop_index(op.f('ix_segment_sentiments_sender_segment_id'), table_name='segment_sentiments')
-    op.drop_table('segment_sentiments')
-    op.drop_index(op.f('ix_message_sentiments_message_id'), table_name='message_sentiments')
-    op.drop_table('message_sentiments')
-    op.drop_table('segments_sender')
-    op.drop_table('segments_time')
-    # ### end Alembic commands ###

alembic/versions/5dd0716c12e2_version_2.py

@@ -1,32 +0,0 @@
-"""version 2
-
-Revision ID: 5dd0716c12e2
-Revises: c5e48c9bf293
-Create Date: 2025-10-07 02:34:56.649412
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '5dd0716c12e2'
-down_revision: Union[str, Sequence[str], None] = 'c5e48c9bf293'
-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! ###
-    pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/9c071425ee4a_version_3.py

@@ -1,32 +0,0 @@
-"""version 3
-
-Revision ID: 9c071425ee4a
-Revises: 5dd0716c12e2
-Create Date: 2025-10-07 20:55:00.457665
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '9c071425ee4a'
-down_revision: Union[str, Sequence[str], None] = '5dd0716c12e2'
-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! ###
-    pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/af5827742674_change_embedding_column_type.py

@@ -1,38 +0,0 @@
-"""change embedding column type
-
-Revision ID: af5827742674
-Revises: c85ba4afc960
-Create Date: 2025-11-28 18:03:09.896314
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'af5827742674'
-down_revision: Union[str, Sequence[str], None] = 'c85ba4afc960'
-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_index(op.f('embeddings_chat_id_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_chat_source_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_embedding_ivfflat'), table_name='embeddings', postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('ix_embeddings_chat_id'), 'embeddings', ['chat_id'], unique=False)
-    # # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    # op.drop_index(op.f('ix_embeddings_chat_id'), table_name='embeddings')
-    # op.create_index(op.f('embeddings_embedding_ivfflat'), 'embeddings', ['embedding'], unique=False, postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('embeddings_chat_source_idx'), 'embeddings', ['chat_id', 'source_table', 'source_id'], unique=False)
-    # op.create_index(op.f('embeddings_chat_id_idx'), 'embeddings', ['chat_id'], unique=False)
-    # # ### end Alembic commands ###

alembic/versions/bbbad8eb92e1_version_7.py

@@ -1,44 +0,0 @@
-"""Version 7
-
-Revision ID: bbbad8eb92e1
-Revises: f8746e269698
-Create Date: 2025-10-13 03:43:39.044102
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'bbbad8eb92e1'
-down_revision: Union[str, Sequence[str], None] = 'f8746e269698'
-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.create_index(op.f('ix_message_sentiments_overall_label'), 'message_sentiments', ['overall_label'], unique=False)
-    op.create_index(op.f('ix_message_sentiments_overall_label_score'), 'message_sentiments', ['overall_label_score'], unique=False)
-    op.alter_column('messages', 'raw',
-               existing_type=sa.TEXT(),
-               nullable=True)
-    op.create_index(op.f('ix_segment_sentiments_overall_label'), 'segment_sentiments', ['overall_label'], unique=False)
-    op.create_index(op.f('ix_segment_sentiments_overall_label_score'), 'segment_sentiments', ['overall_label_score'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index(op.f('ix_segment_sentiments_overall_label_score'), table_name='segment_sentiments')
-    op.drop_index(op.f('ix_segment_sentiments_overall_label'), table_name='segment_sentiments')
-    op.alter_column('messages', 'raw',
-               existing_type=sa.TEXT(),
-               nullable=False)
-    op.drop_index(op.f('ix_message_sentiments_overall_label_score'), table_name='message_sentiments')
-    op.drop_index(op.f('ix_message_sentiments_overall_label'), table_name='message_sentiments')
-    # ### end Alembic commands ###

alembic/versions/c4f1502f712e_create_embeddings_table_and_vector_.py

@@ -1,78 +0,0 @@
-"""create embeddings table and vector extension
-
-Revision ID: c4f1502f712e
-Revises: d77bd9f8ce2f
-Create Date: 2025-11-11 04:08:57.649328
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'c4f1502f712e'
-down_revision: Union[str, Sequence[str], None] = 'd77bd9f8ce2f'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-def upgrade() -> None:
-    # ### commands auto-generated by Alembic - manually adjusted ###
-    
-    # Step 1: Create the vector extension if it doesn't exist 
-    op.execute("CREATE EXTENSION IF NOT EXISTS vector;")
-    
-    # Step 2: Create the embeddings table using the exact DDL [cite: 8-17]
-    # Note: We use 1536 for the embedding dimension as specified [cite: 6, 11]
-    op.execute("""
-        CREATE TABLE public.embeddings (
-            id BIGSERIAL PRIMARY KEY,
-            chat_id INTEGER NOT NULL,
-            source_table TEXT NOT NULL,
-            source_id INTEGER NOT NULL,
-            embedding vector(1536) NOT NULL,
-            text_excerpt TEXT,
-            metadata JSONB DEFAULT '{}'::jsonb,
-            created_at timestamptz DEFAULT now()
-        );
-    """)
-    
-    # Step 3: Add the foreign key constraint to your chats table [cite: 18-20]
-    # This enables ON DELETE CASCADE, as requested by your 4-hour TTL design.
-    op.execute("""
-        ALTER TABLE public.embeddings
-        ADD CONSTRAINT fk_embeddings_chats
-        FOREIGN KEY (chat_id) REFERENCES public.chats (id) ON DELETE CASCADE;
-    """)
-    
-    # Step 4: Create the standard index for chat_id lookups [cite: 22]
-    op.execute("""
-        CREATE INDEX embeddings_chat_id_idx ON public.embeddings (chat_id);
-    """)
-    
-    # Step 5: Create the composite index for common lookups [cite: 24]
-    op.execute("""
-        CREATE INDEX embeddings_chat_source_idx ON public.embeddings (chat_id, source_table, source_id);
-    """)
-    
-    # Step 6: Create the ANN index 
-    # Using 'vector_l2_ops' for Euclidean distance, which the guide's
-    # query operator '<=>' relies on[cite: 132, 141].
-    op.execute("""
-        CREATE INDEX embeddings_embedding_ivfflat ON public.embeddings USING ivfflat (embedding vector_l2_ops) WITH (lists=100);
-    """)
-    
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto-generated by Alembic - manually adjusted ###
-    
-    # Drop the table, which also drops its indexes and constraints
-    op.execute("DROP TABLE IF EXISTS public.embeddings;")
-    
-    # We'll leave the 'vector' extension in place, as it's harmless
-    # and dropping it could affect other tables if you use it elsewhere.
-    
-    # ### end Alembic commands ###

alembic/versions/c5e48c9bf293_initial.py

@@ -1,79 +0,0 @@
-"""initial
-
-Revision ID: c5e48c9bf293
-Revises: 
-Create Date: 2025-10-06 14:10:49.826036
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'c5e48c9bf293'
-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.create_table('chats',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('title', sa.String(length=255), nullable=True),
-    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_table('participants',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('chat_id', sa.Integer(), nullable=False),
-    sa.Column('name', sa.String(length=255), nullable=False),
-    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
-    sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('chat_id', 'name', name='uq_participant_chat_name')
-    )
-    op.create_table('messages',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('chat_id', sa.Integer(), nullable=False),
-    sa.Column('participant_id', sa.Integer(), nullable=True),
-    sa.Column('timestamp', sa.DateTime(), nullable=False),
-    sa.Column('content', sa.Text(), nullable=False),
-    sa.Column('raw', sa.Text(), nullable=False),
-    sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
-    sa.ForeignKeyConstraint(['participant_id'], ['participants.id'], ),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_index(op.f('ix_messages_timestamp'), 'messages', ['timestamp'], unique=False)
-    op.create_table('sentiments',
-    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
-    sa.Column('message_id', sa.Integer(), nullable=False),
-    sa.Column('overall_label', sa.String(length=50), nullable=False),
-    sa.Column('score_positive', sa.Float(), nullable=False),
-    sa.Column('score_negative', sa.Float(), nullable=False),
-    sa.Column('score_neutral', sa.Float(), nullable=False),
-    sa.Column('sentences_summary', sa.JSON(), nullable=True),
-    sa.Column('opinions', sa.JSON(), nullable=True),
-    sa.Column('api_version', sa.String(length=50), nullable=True),
-    sa.Column('analysis_timestamp', sa.DateTime(timezone=True), nullable=False),
-    sa.Column('error_code', sa.String(length=100), nullable=True),
-    sa.Column('error_message', sa.Text(), nullable=True),
-    sa.ForeignKeyConstraint(['message_id'], ['messages.id'], ondelete='CASCADE'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('message_id')
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('sentiments')
-    op.drop_index(op.f('ix_messages_timestamp'), table_name='messages')
-    op.drop_table('messages')
-    op.drop_table('participants')
-    op.drop_table('chats')
-    # ### end Alembic commands ###

alembic/versions/c85ba4afc960_add_new_users_table.py

@@ -1,50 +0,0 @@
-"""add new users table
-
-Revision ID: c85ba4afc960
-Revises: 4de3dfd809bd
-Create Date: 2025-11-23 00:28:21.228614
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'c85ba4afc960'
-down_revision: Union[str, Sequence[str], None] = '4de3dfd809bd'
-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.create_table('users',
-    sa.Column('id', sa.UUID(), nullable=False),
-    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.add_column('chats', sa.Column('owner_id', sa.UUID(), nullable=False))
-    op.create_index(op.f('ix_chats_owner_id'), 'chats', ['owner_id'], unique=False)
-    op.create_foreign_key(None, 'chats', 'users', ['owner_id'], ['id'], ondelete='CASCADE')
-    # op.drop_index(op.f('embeddings_chat_id_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_chat_source_idx'), table_name='embeddings')
-    # op.drop_index(op.f('embeddings_embedding_ivfflat'), table_name='embeddings', postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('ix_embeddings_chat_id'), 'embeddings', ['chat_id'], unique=False)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    # op.drop_index(op.f('ix_embeddings_chat_id'), table_name='embeddings')
-    # op.create_index(op.f('embeddings_embedding_ivfflat'), 'embeddings', ['embedding'], unique=False, postgresql_with={'lists': '100'}, postgresql_using='ivfflat')
-    # op.create_index(op.f('embeddings_chat_source_idx'), 'embeddings', ['chat_id', 'source_table', 'source_id'], unique=False)
-    # op.create_index(op.f('embeddings_chat_id_idx'), 'embeddings', ['chat_id'], unique=False)
-    op.drop_constraint(None, 'chats', type_='foreignkey')
-    op.drop_index(op.f('ix_chats_owner_id'), table_name='chats')
-    op.drop_column('chats', 'owner_id')
-    op.drop_table('users')
-    # ### end Alembic commands ###

alembic/versions/d77bd9f8ce2f_version_10.py

@@ -1,51 +0,0 @@
-"""Version 10
-
-Revision ID: d77bd9f8ce2f
-Revises: 2bae362756b9
-Create Date: 2025-11-02 04:03:43.796576
-
-"""
-from typing import Sequence, Union
-from alembic import op
-import sqlalchemy as sa
-
-# revision identifiers, used by Alembic.
-revision: str = 'd77bd9f8ce2f'
-down_revision: Union[str, Sequence[str], None] = '2bae362756b9'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    # Step 1: Add columns as nullable
-    op.add_column('messages', sa.Column('word_count', sa.Integer(), nullable=True))
-    op.add_column('messages', sa.Column('emojis_count', sa.Integer(), nullable=True))
-    op.add_column('messages', sa.Column('links_count', sa.Integer(), nullable=True))
-    op.add_column('messages', sa.Column('is_question', sa.Boolean(), nullable=True))
-    op.add_column('messages', sa.Column('is_media', sa.Boolean(), nullable=True))
-    
-    # Step 2: Update existing rows with default values
-    op.execute("""
-        UPDATE messages 
-        SET word_count = 0,
-            emojis_count = 0,
-            links_count = 0,
-            is_question = FALSE,
-            is_media = FALSE
-        WHERE word_count IS NULL
-    """)
-    
-    # Step 3: Make columns non-nullable
-    op.alter_column('messages', 'word_count', nullable=False)
-    op.alter_column('messages', 'emojis_count', nullable=False)
-    op.alter_column('messages', 'links_count', nullable=False)
-    op.alter_column('messages', 'is_question', nullable=False)
-    op.alter_column('messages', 'is_media', nullable=False)
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_column('messages', 'is_media')
-    op.drop_column('messages', 'is_question')
-    op.drop_column('messages', 'links_count')
-    op.drop_column('messages', 'emojis_count')
-    op.drop_column('messages', 'word_count')

alembic/versions/e817f10d0cc8_rename_metadata_column_on_embeddings_.py

@@ -1,44 +0,0 @@
-"""rename metadata column on embeddings table
-
-Revision ID: e817f10d0cc8
-Revises: c4f1502f712e
-Create Date: 2025-11-12 11:55:54.052188
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = 'e817f10d0cc8'
-down_revision: Union[str, Sequence[str], None] = 'c4f1502f712e'
-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.add_column('embeddings', sa.Column('chunk_metadata', sa.JSON(), nullable=True))
-    op.alter_column('embeddings', 'created_at',
-               existing_type=postgresql.TIMESTAMP(timezone=True),
-               nullable=False,
-               existing_server_default=sa.text('now()'))
-    
-    op.drop_column('embeddings', 'metadata')
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('embeddings', sa.Column('metadata', postgresql.JSONB(astext_type=sa.Text()), server_default=sa.text("'{}'::jsonb"), autoincrement=False, nullable=True))
-    
-    op.alter_column('embeddings', 'created_at',
-               existing_type=postgresql.TIMESTAMP(timezone=True),
-               nullable=True,
-               existing_server_default=sa.text('now()'))
-    op.drop_column('embeddings', 'chunk_metadata')
-    # ### end Alembic commands ###

alembic/versions/f8746e269698_version_6.py

@@ -1,70 +0,0 @@
-"""Version 6
-
-Revision ID: f8746e269698
-Revises: 51088f15a504
-Create Date: 2025-10-12 20:42:52.982015
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'f8746e269698'
-down_revision: Union[str, Sequence[str], None] = '51088f15a504'
-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.add_column('message_sentiments', sa.Column('overall_label_score', sa.Float(), nullable=False))
-    op.alter_column('message_sentiments', 'score_positive',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    op.alter_column('message_sentiments', 'score_negative',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    op.alter_column('message_sentiments', 'score_neutral',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    op.add_column('segment_sentiments', sa.Column('overall_label_score', sa.Float(), nullable=False))
-    op.alter_column('segment_sentiments', 'score_positive',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    op.alter_column('segment_sentiments', 'score_negative',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    op.alter_column('segment_sentiments', 'score_neutral',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=True)
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('segment_sentiments', 'score_neutral',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.alter_column('segment_sentiments', 'score_negative',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.alter_column('segment_sentiments', 'score_positive',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.drop_column('segment_sentiments', 'overall_label_score')
-    op.alter_column('message_sentiments', 'score_neutral',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.alter_column('message_sentiments', 'score_negative',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.alter_column('message_sentiments', 'score_positive',
-               existing_type=sa.DOUBLE_PRECISION(precision=53),
-               nullable=False)
-    op.drop_column('message_sentiments', 'overall_label_score')
-    # ### end Alembic commands ###

kb_docs.py

@@ -0,0 +1,19 @@
+KB_DOCS = [
+    {"id": "shipping_times",
+        "text": "Standard delivery takes 3–5 business days within major cities and 5–8 business days for other locations. Express delivery (1–2 business days) is available at checkout for an additional fee. Orders placed before 2pm ship the same day."},
+    {"id": "shipping_costs", "text": "Standard shipping is free on orders over ₦50,000. Orders below that threshold have a flat ₦2,500 shipping fee. Express shipping is calculated at checkout based on weight and destination."},
+    {"id": "returns", "text": "Items can be returned within 14 days of delivery if unused, in original packaging, with proof of purchase. Perishable items and opened personal-care products are not eligible for return."},
+    {"id": "refunds", "text": "Once a return is received and inspected, refunds are processed within 5–7 business days to the original payment method. You'll get an email confirmation when the refund is issued."},
+    {"id": "tracking", "text": "A tracking link is emailed automatically once an order ships. Tracking can also be checked by logging into your account under 'My Orders.'"},
+    {"id": "payment", "text": "We accept debit/credit cards, bank transfer, and major mobile payment wallets. Payment is processed securely at checkout; we never store full card details."},
+    {"id": "warranty",
+        "text": "All small appliances (blenders, kettles, toasters, etc.) come with a 12-month manufacturer warranty covering defects. Warranty claims require the original receipt and are handled through the manufacturer's service center."},
+    {"id": "cookware_care", "text": "Non-stick cookware should be hand-washed with a soft sponge — no metal utensils or abrasive scrubbers, as these damage the coating. Avoid high heat above medium for non-stick pans to preserve the coating's lifespan."},
+    {"id": "wholesale", "text": "For orders over 20 units of the same item, contact our sales team directly for wholesale pricing. Bulk orders typically ship within 7–10 business days depending on stock."},
+    {"id": "damaged_item", "text": "If an item arrives damaged, contact support within 48 hours with photos of the damage and packaging. A replacement or full refund will be issued — no need to return the damaged item in most cases."},
+    {"id": "cancellation", "text": "Orders can be cancelled free of charge within 1 hour of placing them. After that, the order may already be processing and cancellation isn't guaranteed — contact support immediately if this happens."},
+    {"id": "gift_wrapping", "text": "Gift wrapping is available at checkout for a small fee and includes a printed gift note if you add a message. Gift cards are available in fixed denominations and don't expire."},
+    {"id": "international", "text": "We currently ship only within the country. International shipping isn't available yet, but you can sign up for restock/expansion notifications on the homepage."},
+    {"id": "pickup", "text": "Store pickup isn't currently offered — all orders are delivered directly to the address provided at checkout."},
+    {"id": "escalation", "text": "If a question falls outside what I can answer, or you'd prefer to speak with a person directly, I'll flag it for the team and someone will follow up by email within one business day."},
+]

main.py

@@ -0,0 +1,79 @@
+import os
+import numpy as np
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from sentence_transformers import SentenceTransformer
+from groq import Groq
+from dotenv import load_dotenv
+from kb_docs import KB_DOCS
+
+load_dotenv()
+app = FastAPI()
+
+# Allow your Vercel frontend to reach this backend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["POST", "GET"],
+    allow_headers=["*"],
+)
+
+print("Initializing Embedding Model...")
+embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+texts = [d["text"] for d in KB_DOCS]
+kb_embeddings = embed_model.encode(texts, normalize_embeddings=True)
+print("Embeddings loaded into memory.")
+
+groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY", ""))
+
+SYSTEM_PROMPT = """You are the customer support assistant for Amara Home & Kitchen, an online kitchenware and home-goods retailer.
+Answer ONLY using the information provided below. Keep answers short — 2-4 sentences.
+If the answer isn't in the information provided, say you'll connect them with a human team member rather than guessing.
+Never invent policies, prices, or timelines that aren't in the information.
+
+INFORMATION:
+{context}
+"""
+
+
+class ChatRequest(BaseModel):
+    question: str
+
+
+def retrieve(question: str, top_k: int = 3):
+    q_emb = embed_model.encode([question], normalize_embeddings=True)[0]
+    sims = kb_embeddings @ q_emb
+    top_idx = np.argsort(sims)[::-1][:top_k]
+    return [KB_DOCS[i]["text"] for i in top_idx]
+
+
+def ask_groq(question: str, context: str, model: str = "llama-3.3-70b-versatile"):
+    resp = groq_client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT.format(
+                context=context)},
+            {"role": "user", "content": question},
+        ],
+        temperature=0.2,
+        max_tokens=300,
+    )
+    return resp.choices[0].message.content
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/api/rag/chat")
+def chat(req: ChatRequest):
+    context_chunks = retrieve(req.question)
+    context = "\n".join(context_chunks)
+    try:
+        answer = ask_groq(req.question, context,
+                          model="llama-3.3-70b-versatile")
+    except Exception:
+        answer = ask_groq(req.question, context, model="llama-3.1-8b-instant")
+    return {"answer": answer}

onnx_model_optimized/config.json

@@ -1,46 +0,0 @@
-{
-  "adapters": {
-    "adapters": {},
-    "config_map": {},
-    "fusion_config_map": {},
-    "fusions": {}
-  },
-  "architectures": [
-    "XLMRobertaForSequenceClassification"
-  ],
-  "attention_probs_dropout_prob": 0.1,
-  "bos_token_id": 0,
-  "classifier_dropout": null,
-  "eos_token_id": 2,
-  "gradient_checkpointing": false,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "id2label": {
-    "0": "positive",
-    "1": "neutral",
-    "2": "negative"
-  },
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "label2id": {
-    "negative": 2,
-    "neutral": 1,
-    "positive": 0
-  },
-  "layer_norm_eps": 1e-05,
-  "max_length": 512,
-  "max_position_embeddings": 514,
-  "model_type": "xlm-roberta",
-  "num_attention_heads": 6,
-  "num_hidden_layers": 10,
-  "output_past": true,
-  "pad_token_id": 1,
-  "position_embedding_type": "absolute",
-  "problem_type": "single_label_classification",
-  "torch_dtype": "float32",
-  "transformers_version": "4.55.4",
-  "type_vocab_size": 1,
-  "use_cache": true,
-  "vocab_size": 70006
-}

onnx_model_optimized/ort_config.json

@@ -1,33 +0,0 @@
-{
-  "one_external_file": true,
-  "opset": null,
-  "optimization": {},
-  "quantization": {
-    "activations_dtype": "QUInt8",
-    "activations_symmetric": false,
-    "format": "QOperator",
-    "is_static": false,
-    "mode": "IntegerOps",
-    "nodes_to_exclude": [],
-    "nodes_to_quantize": [],
-    "operators_to_quantize": [
-      "Conv",
-      "MatMul",
-      "Attention",
-      "LSTM",
-      "Gather",
-      "Transpose",
-      "EmbedLayerNormalization"
-    ],
-    "per_channel": true,
-    "qdq_add_pair_to_weight": false,
-    "qdq_dedicated_pair": false,
-    "qdq_op_type_per_channel_support_to_axis": {
-      "MatMul": 1
-    },
-    "reduce_range": false,
-    "weights_dtype": "QUInt8",
-    "weights_symmetric": true
-  },
-  "use_external_data_format": false
-}

onnx_model_optimized/special_tokens_map.json

@@ -1,51 +0,0 @@
-{
-  "bos_token": {
-    "content": "<s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "cls_token": {
-    "content": "<s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "eos_token": {
-    "content": "</s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "mask_token": {
-    "content": "<mask>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "pad_token": {
-    "content": "<pad>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "sep_token": {
-    "content": "</s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "unk_token": {
-    "content": "<unk>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  }
-}

onnx_model_optimized/tokenizer_config.json

@@ -1,57 +0,0 @@
-{
-  "added_tokens_decoder": {
-    "0": {
-      "content": "<s>",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "1": {
-      "content": "<pad>",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "2": {
-      "content": "</s>",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "4": {
-      "content": "<unk>",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    },
-    "70005": {
-      "content": "<mask>",
-      "lstrip": false,
-      "normalized": false,
-      "rstrip": false,
-      "single_word": false,
-      "special": true
-    }
-  },
-  "bos_token": "<s>",
-  "clean_up_tokenization_spaces": false,
-  "cls_token": "<s>",
-  "do_lower_case": false,
-  "eos_token": "</s>",
-  "extra_special_tokens": {},
-  "mask_token": "<mask>",
-  "model_max_length": 1000000000000000019884624838656,
-  "pad_token": "<pad>",
-  "sep_token": "</s>",
-  "sp_model_kwargs": {},
-  "tokenizer_class": "XLMRobertaTokenizerFast",
-  "unk_token": "<unk>"
-}

pytest.ini

@@ -1,2 +0,0 @@
-[pytest]
-pythonpath = .

requirements.txt

@@ -1,125 +1,6 @@
---extra-index-url https://download.pytorch.org/whl/cpu
-
-# --- Core Async & Web ---
-aiofiles
-aiohappyeyeballs
-aiohttp
-aiosignal
-aiosqlite
-anyio
-asyncpg
-fastapi
-h11
-httpcore
-httpx
-httpx-sse
-starlette
-uvicorn
-python-multipart
-slowapi
-limits
-email-validator
-dnspython
-
-# --- Database & Migrations ---
-alembic
-sqlalchemy
-psycopg-binary
-psycopg
-redis
-greenlet
-pgvector
-qdrant-client
-
-# --- Auth & Security ---
-PyJWT
-passlib[bcrypt]
-python-jose
-python-dotenv
-
-# --- AI, ML & Data Science ---
-torch
-transformers
-optimum[onnxruntime]
-onnxruntime
-onnx
-scikit-learn
-scipy
-numpy
-pandas
-networkx
-tiktoken
-tokenizers
-safetensors
-regex
-pydantic
-pydantic-settings
-pydantic_core
-
-# --- Azure & OpenAI ---
-openai
-azure-ai-inference
-azure-ai-textanalytics
-azure-common
-azure-core
-
-# --- LangChain Ecosystem ---
-langchain
-langchain-classic
-langchain-community
-langchain-core
-langchain-openai
-langchain-text-splitters
-langgraph
-langgraph-checkpoint
-langgraph-prebuilt
-langgraph-sdk
-langsmith
-
-# --- Celery & Queue ---
-celery
-kombu
-amqp
-billiard
-vine
-
-# --- Utilities & processing ---
-requests
-requests-toolbelt
-tqdm
-colorama
-coloredlogs
-click
-click-didyoumean
-click-plugins
-click-repl
-cachetools
-charset-normalizer
-idna
-jinja2
-joblib
-marshmallow
-multidict
-packaging
-pillow
-protobuf
-python-dateutil
-pytz
-pyyaml
-six
-tenacity
-typing-extensions
-urllib3
-wrapt
-xxhash
-yarl
-zstandard
-fsspec
-huggingface-hub
-filelock
-frozenlist
-attrs
-annotated-types
-certifi
-soupsieve
-beautifulsoup4
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+sentence-transformers==3.3.1
+numpy==1.26.4
+groq==0.13.0
+python-dotenv==1.0.1

src/app/celery_app.py

@@ -1,54 +0,0 @@
-# src/app/celery_app.py
-
-import os
-import ssl
-from celery import Celery
-from src.app.config import settings
-
-
-# Priority list for the broker
-BROKER_FAILOVER_LIST = [str(settings.CELERY_BROKER_URL), "redis://localhost:6379/0"]
-
-celery_app = Celery(
-    "chat_processor",
-    broker=BROKER_FAILOVER_LIST, # Celery will try these in order
-    include=["src.app.services.sentiment_worker", "src.app.services.embedding_worker"]
-)
-
-ssl_options = {
-    'ssl_cert_reqs': ssl.CERT_NONE
-}
-
-celery_app.conf.update(
-    # Broker & Backend Settings
-    result_backend=settings.CELERY_RESULT_BACKEND,
-    broker_use_ssl=ssl_options,
-    redis_backend_use_ssl=ssl_options,
-    
-    # Critical Connection Resilience
-    broker_transport_options={
-        'visibility_timeout': 3600,
-        'socket_timeout': 30,
-        'socket_keepalive': True,
-        'health_check_interval': 15, # Ping every 15s to keep Upstash alive
-        'retry_on_timeout': True,
-    },
-
-    # Task Settings
-    task_serializer="json",
-    accept_content=["json"],
-    result_serializer="json",
-    timezone="UTC",
-    enable_utc=True,
-    task_acks_late=True, # Critical: allows continuation after fallback
-    
-    # Worker Settings
-    worker_prefetch_multiplier=1,
-    worker_cancel_long_running_tasks_on_connection_loss=True,
-    
-    # Routing
-    task_routes={
-        'src.app.services.embedding_worker.generate_embeddings_task': {'queue': 'embeddings'},
-        'src.app.services.sentiment_worker.analyze_sentiment_task': {'queue': 'sentiment'},
-    }
-)

src/app/config.py

@@ -1,122 +0,0 @@
-from pydantic import AnyUrl, AnyHttpUrl, field_validator, PostgresDsn, model_validator
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from typing import Optional, List
-import secrets
-import logging
-import logging.config
-
-
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_file=".env")
-
-    PROJECT_NAME: str = "SentimentScope API"
-    APP_NAME: str = PROJECT_NAME  
-    ENVIRONMENT: str = "development"
-
-    DB_USER: str
-    DB_PASSWORD: str
-    DB_HOST: str 
-    DB_PORT: int
-    DB_NAME: str
-    DATABASE_URL: Optional[PostgresDsn] = None
-
-    # Azure OpenAI configs...
-    AZURE_OPENAI_ENDPOINT: AnyHttpUrl
-    AZURE_OPENAI_API_KEY: str
-    AZURE_OPENAI_DEPLOYMENT: str
-    AZURE_OPENAI_API_VERSION: str
-    AZURE_OPENAI_ENDPOINT_CONTEXT_4: AnyHttpUrl
-    AZURE_OPENAI_DEPLOYMENT_CONTEXT_4: str
-    AZURE_OPENAI_API_KEY_CONTEXT_4: str
-    AZURE_OPENAI_API_VERSION_CONTEXT_4: str
-    AZURE_OPENAI_ENDPOINT_ROUTER: AnyHttpUrl
-    AZURE_OPENAI_DEPLOYMENT_ROUTER: str
-    AZURE_OPENAI_API_KEY_ROUTER: str
-    AZURE_OPENAI_API_VERSION_ROUTER: str
-    # AZURE_OPENAI_ENDPOINT_MAIN: AnyHttpUrl
-    # AZURE_OPENAI_DEPLOYMENT_MAIN: str
-    # AZURE_OPENAI_API_KEY_MAIN: str
-    # AZURE_OPENAI_API_VERSION_MAIN: str
-    AZURE_OPENAI_ENDPOINT_CONTEXT_4O: AnyHttpUrl
-    AZURE_OPENAI_DEPLOYMENT_CONTEXT_4O: str
-    AZURE_OPENAI_API_KEY_CONTEXT_4O: str
-    AZURE_OPENAI_API_VERSION_CONTEXT_4O: str
-    AZURE_OPENAI_ENDPOINT_MAIN_4O: AnyHttpUrl
-    AZURE_OPENAI_DEPLOYMENT_MAIN_4O: str
-    AZURE_OPENAI_API_KEY_MAIN_4O: str
-    AZURE_OPENAI_API_VERSION_MAIN_4O: str
-    AZURE_OPENAI_ENDPOINT_MAIN_4O_MINI: AnyHttpUrl
-    AZURE_OPENAI_DEPLOYMENT_MAIN_4O_MINI: str
-    AZURE_OPENAI_API_KEY_MAIN_4O_MINI: str
-    AZURE_OPENAI_API_VERSION_MAIN_4O_MINI: str
-    AZURE_LANGUAGE_ENDPOINT: Optional[str] = None
-    AZURE_LANGUAGE_KEY: Optional[str] = None
-
-    SECRET_KEY: str = secrets.token_urlsafe(32)
-    IS_CELERY_WORKER: str = "false"
-    CELERY_BROKER_URL: Optional[str] = None
-    CELERY_RESULT_BACKEND: Optional[str] = None
-    QDRANT_URL: str
-    QDRANT_API_KEY: str
-    CORS_ORIGINS: List[str] = []
-    JWT_ALGORITHM: str
-    JWT_ACCESS_TOKEN_EXPIRE_DAYS: int 
-    
-    CORS_ALLOW_CREDENTIALS: bool = True
-    TRUSTED_HOSTS: List[str] = ["*"]
-
-
-    DB_CONNECT_RETRIES: int = 3
-    DB_CONNECT_BACKOFF_SECONDS: int = 2
-
-    DEBUG: bool = True
-    LOG_LEVEL: str = "INFO"
-
-    MAX_UPLOAD_SIZE_BYTES: int = 10 * 1024 * 1024  # 10 MB
-
-    @model_validator(mode="before")
-    @classmethod
-    def assemble_database_url(cls, values):
-        # 1. Check if URL is provided directly
-        if values.get("DATABASE_URL"):
-            url = str(values.get("DATABASE_URL"))
-            # If it starts with postgresql:// but not postgresql+asyncpg://, fix it
-            if url.startswith("postgresql://") and "asyncpg" not in url:
-                values["DATABASE_URL"] = url.replace("postgresql://", "postgresql+asyncpg://", 1)
-        
-        # 2. If no URL provided, assemble it from parts (your existing logic)
-        elif not values.get("DATABASE_URL"):
-            user = values.get("DB_USER")
-            password = values.get("DB_PASSWORD")
-            host = values.get("DB_HOST")
-            port = values.get("DB_PORT")
-            db = values.get("DB_NAME")
-
-            values["DATABASE_URL"] = (
-                f"postgresql+asyncpg://{user}:{password}@{host}:{port}/{db}"
-            )
-            
-        return values
-
-settings = Settings()
-
-
-
-def setup_logging():
-    """Configure global logging level and format based on settings."""
-    log_level = getattr(logging, settings.LOG_LEVEL.upper(), logging.INFO)
-
-    logging.basicConfig(
-        level=log_level,
-        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-    )
-
-    # Suppress noisy loggers from dependencies
-    # logging.getLogger("uvicorn").setLevel(logging.WARNING)
-    # logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
-    logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)
-    # logging.getLogger("asyncio").setLevel(logging.WARNING)
-    # logging.getLogger("httpx").setLevel(logging.WARNING)
-    logging.getLogger("multipart").setLevel(logging.WARNING)

src/app/crud.py

@@ -1,783 +0,0 @@
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.future import select
-from sqlalchemy import insert, func, delete, select
-from sqlalchemy.orm import selectinload, joinedload
-from typing import List, Optional, Dict, Tuple, AsyncGenerator
-from src.app import models, schemas
-from src.app.utils.raw_txt_parser import CleanedMessage
-from src.app.utils.message_analytics import compute_message_analytics
-from datetime import date, datetime, time
-import uuid
-
-TIME_PERIOD_BUCKETS = {
-    "Morning": [6, 7, 8, 9, 10, 11],
-    "Afternoon": [12, 13, 14, 15, 16],
-    "Evening": [17, 18, 19, 20],
-    "Night": [21, 22, 23, 0, 1, 2, 3, 4, 5]
-}
-
-
-async def create_chat(db: AsyncSession, owner_id: uuid.UUID,  title: Optional[str] = None, should_commit: bool = True) -> models.Chat:
-    new_chat = models.Chat(title=title, owner_id=owner_id)
-    db.add(new_chat)
-    await db.flush()
-
-    if should_commit:
-        await db.commit()
-        await db.refresh(new_chat)
-    return new_chat
-
-
-async def get_chat(db: AsyncSession, chat_id: int) -> Optional[models.Chat]:
-    result = await db.execute(select(models.Chat).where(models.Chat.id == chat_id))
-    return result.scalars().first()
-
-      
-
-async def get_all_chats(db: AsyncSession) -> List[models.Chat]:
-    result = await db.execute(select(models.Chat).order_by(models.Chat.created_at.desc()))
-    return result.scalars().all()
-
-async def get_chat_by_name(db: AsyncSession, chat_name: str) -> Optional[models.Chat]:
-    chat_res = await db.execute(
-        select(models.Chat).where(models.Chat.title == chat_name.strip())
-    )
-    return chat_res.scalars().first()
-
-
-
-
-async def delete_chat(db: AsyncSession, chat_id: int, should_commit: bool = True) -> bool:
-    chat = await get_chat(db, chat_id=chat_id)
-    if chat:
-        await db.execute(delete(models.Chat).where(models.Chat.id == chat_id))
-        if should_commit:
-            await db.commit()
-        return True
-    return False
-
-
-
-async def request_chat_cancel(db: AsyncSession, chat_id: int) -> bool:
-    result = await db.execute(select(models.Chat).filter(models.Chat.id == chat_id))
-    chat = result.scalars().first()
-    if chat:
-        chat.cancel_requested = True
-        await db.commit()
-        return True
-    return False
-
-
-async def is_chat_cancelled(db: AsyncSession, chat_id: int) -> bool:
-    result = await db.execute(select(models.Chat.cancel_requested).filter(models.Chat.id == chat_id))
-    cancelled = result.scalar()
-    return bool(cancelled)
-
-async def update_chat_status(db: AsyncSession, chat_id: int, status: str):
-    chat = await get_chat(db, chat_id)
-    if chat:
-        chat.sentiment_status = status
-        db.add(chat)
-        await db.commit()
-
-async def update_chat_embedding_status(db: AsyncSession, chat_id: int, status: str, should_commit: bool = True):
-    chat = await get_chat(db, chat_id)
-    if chat:
-        chat.embeddings_status = status
-        db.add(chat)
-        if should_commit:
-            await db.commit()
-
-
-async def get_chat_embedding_status(db: AsyncSession, chat_id: int) -> Optional[str]:
-    """
-    Quickly get just the embeddings_status of a chat.
-    """
-    result = await db.execute(
-        select(models.Chat.embeddings_status)
-        .where(models.Chat.id == chat_id)
-    )
-    return result.scalar_one_or_none()
-
-async def get_chat_status(db: AsyncSession, chat_id: int) -> Optional[str]:
-    """
-    Quickly get just the sentiment_status of a chat.
-    """
-    result = await db.execute(
-        select(models.Chat.sentiment_status)
-        .where(models.Chat.id == chat_id)
-    )
-    return result.scalar_one_or_none()
-
-async def get_conversation_history(
-    db: AsyncSession, 
-    chat_id: int, 
-    limit: int = 6 # Fetch last 6 turns (3 pairs) to save tokens
-) -> List[models.ConversationHistory]:
-    stmt = (
-        select(models.ConversationHistory)
-        .where(models.ConversationHistory.chat_id == chat_id)
-        .order_by(models.ConversationHistory.created_at.desc()) # Get newest first
-        .limit(limit)
-    )
-    result = await db.execute(stmt)
-    # Reverse to return chronological order (Oldest -> Newest)
-    return result.scalars().all()[::-1] 
-
-async def add_conversation_turn(
-    db: AsyncSession, 
-    chat_id: int, 
-    user_q: str, 
-    ai_a: str,
-    sources: Optional[List[dict]] = None
-):
-    """Saves both user query and AI response in a transaction."""
-    user_msg = models.ConversationHistory(chat_id=chat_id, role="user", content=user_q, sources=None)
-    ai_msg = models.ConversationHistory(chat_id=chat_id, role="assistant", content=ai_a, sources=sources)
-    db.add_all([user_msg, ai_msg])
-    await db.commit()
-
-async def get_messages_batch(
-    db: AsyncSession,
-    chat_id: int,
-    limit: int,
-    offset: int,
-    min_date: Optional[datetime] = None
-) -> List[models.Message]:
-    """
-    Fetches a batch of messages for a chat with optional filtering by minimum date.
-    """
-    stmt = (
-        select(models.Message)
-        .where(models.Message.chat_id == chat_id)
-    )
-
-    # Optional min timestamp
-    if min_date:
-        stmt = stmt.where(models.Message.timestamp >= min_date)
-
-    # Pagination + ordering
-    stmt = (
-        stmt.order_by(models.Message.timestamp.desc())
-            .limit(limit)
-            .offset(offset)
-    )
-
-    result = await db.execute(stmt)
-    return result.scalars().all()
-
-
-
-
-
-
-
-
-
-
-
-async def clear_conversation_history(db: AsyncSession, chat_id: int):
-
-    await db.execute(
-        delete(models.ConversationHistory)
-        .where(models.ConversationHistory.chat_id == chat_id)
-    )
-    await db.commit()
-
-async def get_full_conversation_history(
-    db: AsyncSession, 
-    chat_id: int
-) -> List[models.ConversationHistory]:
-    """
-    Fetches the complete history for a chat session to restore the UI state.
-    Ordered purely chronologically (Oldest -> Newest).
-    """
-    stmt = (
-        select(models.ConversationHistory)
-        .where(models.ConversationHistory.chat_id == chat_id)
-        .order_by(models.ConversationHistory.created_at.asc())
-    )
-    result = await db.execute(stmt)
-    return result.scalars().all()
-
-
-async def create_participant(db: AsyncSession, chat_id: int, name: str, should_commit: bool = True) -> models.Participant:
-    new_participant = models.Participant(chat_id=chat_id, name=name)
-    db.add(new_participant)
-    await db.flush()
-    if should_commit:
-        await db.commit()
-        await db.refresh(new_participant)
-    return new_participant
-
-
-async def bulk_insert_participants(db: AsyncSession, chat_id: int, names: List[str], should_commit: bool = True) -> List[models.Participant]:
-    # Fetch existing participants to avoid duplicates
-    existing_q = await db.execute(select(models.Participant).where(models.Participant.chat_id == chat_id))
-    already_existing = {p.name: p for p in existing_q.scalars().all()}
-    to_create = [models.Participant(chat_id=chat_id, name=name) for name in names if name not in already_existing]
-    
-    if to_create:
-        db.add_all(to_create)
-        await db.flush()
-
-    if should_commit:
-        await db.commit()
-        for p in to_create:
-            await db.refresh(p) 
-
-    q = await db.execute(select(models.Participant).where(models.Participant.chat_id == chat_id))
-    return q.scalars().all()
-
-async def get_participants_by_chat(db: AsyncSession, chat_id: int) -> List[models.Participant]:
-    result = await db.execute(select(models.Participant).where(models.Participant.chat_id == chat_id))
-    return result.scalars().all()
-
-
-
-async def create_message(db: AsyncSession, message: schemas.MessageCreate, chat_id: int, participant_id: Optional[int], should_commit: bool = True) -> models.Message:
-    # Compute analytics for the message
-    analytics = compute_message_analytics(message.content)
-    
-    new_msg = models.Message(
-        chat_id=chat_id,
-        participant_id=participant_id,
-        timestamp=message.timestamp,
-        content=message.content,
-        raw=getattr(message, "raw", None) or message.content,  # Use content if raw is not provided
-        word_count=analytics['word_count'],
-        emojis_count=analytics['emojis_count'],
-        links_count=analytics['links_count'],
-        is_question=analytics['is_question'],
-        is_media=analytics['is_media']
-    )
-    db.add(new_msg)
-    await db.flush()
-    if should_commit:  
-        await db.commit()
-        await db.refresh(new_msg)
-    return new_msg
-
-
-async def bulk_insert_messages(
-    db: AsyncSession,
-    messages: List[dict],
-    should_commit: bool = True
-) -> List[int]:
-    if not messages:
-        return []
-
-    try:
-        CHUNK_SIZE = 2500
-        inserted_ids = []
-
-        for i in range(0, len(messages), CHUNK_SIZE):
-            chunk = messages[i:i + CHUNK_SIZE]
-            stmt = insert(models.Message).values(chunk).returning(models.Message.id)
-            result = await db.execute(stmt)
-            inserted_ids.extend(result.scalars().all())
-
-        if should_commit:
-            await db.commit()
-
-        return inserted_ids
-
-    except SQLAlchemyError:
-        await db.rollback()
-        raise
-
-
-
-async def get_messages_by_chat(db: AsyncSession, chat_id: int) -> List[models.Message]:
-    result = await db.execute(select(models.Message).where(models.Message.chat_id == chat_id))
-    return result.scalars().all()
-
-async def get_all_sender_segments_for_chat(db: AsyncSession, chat_id: int) -> List[models.SenderSegment]:
-    stmt = (
-        select(models.SenderSegment)
-        .join(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-    )
-    result = await db.execute(stmt)
-    return result.scalars().all()
-
-async def get_segments_batch(
-    db: AsyncSession,
-    chat_id: int,
-    limit: int,
-    offset: int,
-    min_date: Optional[datetime] = None
-) -> List[models.SenderSegment]:
-
-    stmt = (
-        select(models.SenderSegment)
-        .join(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-    )
-
-    if min_date:
-        stmt = stmt.where(models.TimeSegment.start_time >= min_date)
-
-    stmt = (
-        stmt.order_by(models.TimeSegment.start_time.desc())
-            .limit(limit)
-            .offset(offset)
-    )
-
-    result = await db.execute(stmt)
-    return result.scalars().all()
-
-
-# Issues here to handle later
-async def delete_message(db: AsyncSession, message_id: int, should_commit: bool = True) -> bool:
-    
-    try:
-        result = await db.execute(select(models.Message).where(models.Message.id == message_id))
-        message = result.scalars().first()
-        if not message:
-            return False
-        
-        participant_id = message.participant_id
-        chat_id = message.chat_id
-
-        await db.delete(message)
-
-        if participant_id:
-            other_messages_query = await db.execute(
-                select(models.Message).where(
-                    models.Message.chat_id == chat_id,
-                    models.Message.participant_id == participant_id
-                )
-            )
-
-            rem_messages = other_messages_query.scalars().first()
-            if not rem_messages:
-                participant = await db.get(models.Participant, participant_id)
-                if participant:
-                    await db.delete(participant)
-        if should_commit:
-            await db.commit()
-                    
-        return True
-    except Exception:
-        if should_commit:
-            await db.rollback()
-        raise
-
-async def create_sender_segment(
-    db: AsyncSession,
-    time_segment_id: int,
-    sender_id: int,
-    sender_details: dict,
-    should_commit: bool = True
-):
-    seg = models.SenderSegment(
-        time_segment_id=time_segment_id,
-        sender_id=sender_id,
-        message_count=sender_details.get("message_count"),
-        combined_text=sender_details.get("combined_text", "")
-    )
-    db.add(seg)
-    await db.flush()
-    if should_commit:
-        await db.commit()
-        await db.refresh(seg)
-    return seg
-
-    
-
-async def create_time_segment(
-    db: AsyncSession,
-    chat_id: int,
-    time_segment_details: dict,
-    should_commit: bool = True
-) -> models.TimeSegment:
-    seg = models.TimeSegment(
-        chat_id=chat_id,
-        start_time=time_segment_details.get("start_time"),
-        end_time=time_segment_details.get("end_time"),
-        duration_minutes=time_segment_details.get("duration_minutes"),
-        message_count=time_segment_details.get("message_count"),
-        summary=time_segment_details.get("summary", None)
-    )
-    db.add(seg)
-    await db.flush()
-    if should_commit:
-        await db.commit()
-        await db.refresh(seg)
-    return seg
-
-
-async def bulk_insert_segments(
-    db: AsyncSession,
-    chat_id: int,
-    participants_map: dict,
-    time_segments_list: List[dict]
-) -> int:
-    if not time_segments_list:
-        return 0
-
-    # Build all TimeSegment objects
-    time_segments = [
-        models.TimeSegment(
-            chat_id=chat_id,
-            start_time=seg.get("start_time"),
-            end_time=seg.get("end_time"),
-            duration_minutes=seg.get("duration_minutes"),
-            message_count=seg.get("message_count"),
-            summary=seg.get("summary")
-        )
-        for seg in time_segments_list
-    ]
-
-    # Bulk add time segments
-    db.add_all(time_segments)
-    await db.flush()  # Assign IDs
-
-    # Build all SenderSegment objects linked to their TimeSegments
-    sender_segments = []
-    for seg_obj, seg_dict in zip(time_segments, time_segments_list):
-        sender_groups = seg_dict.get("sender_groups", {})
-        for sender, details in sender_groups.items():
-            sender_id = participants_map.get(sender)
-            if not sender_id:
-                continue
-            sender_segments.append(models.SenderSegment(
-                time_segment_id=seg_obj.id,
-                sender_id=sender_id,
-                message_count=details.get("message_count"),
-                combined_text=details.get("combined_text", "")
-            ))
-
-    if sender_segments:
-        db.add_all(sender_segments)
-        await db.flush()
-
-    return len(time_segments)
-
-async def get_sender_segments_by_sender_id(db: AsyncSession, sender_id: int) -> List[models.SenderSegment]:
-    result = await db.execute(
-        select(models.SenderSegment)
-        .where(models.SenderSegment.sender_id == sender_id)
-    )
-    return result.scalars().all()
-
-async def get_all_time_segments(db: AsyncSession, chat_id: int) -> List[models.TimeSegment]:
-    result = await db.execute(
-        select(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-    )
-    return result.scalars().all()
-
-async def create_message_sentiment(
-        db: AsyncSession,
-        msg_id: int,
-        payload: dict,
-        should_commit: bool = True
-) -> models.MessageSentiment:
-    s = models.MessageSentiment(message_id = msg_id, **payload)
-    db.add(s)
-    await db.flush()
-
-    if should_commit:
-        await db.commit()
-        await db.refresh(s)
-    return s
-
-async def create_segment_sentiment(
-        db: AsyncSession,
-        sender_segment_id: int,
-        payload: dict,
-        should_commit: bool = True
-) -> models.SegmentSentiment:
-    s = models.SegmentSentiment(sender_segment_id=sender_segment_id, **payload)
-    db.add(s)
-    await db.flush()
-
-    if should_commit:
-        await db.commit()
-        await db.refresh(s)
-    return s
-    
-
-async def get_sentiment_progress(db: AsyncSession, chat_id: int):
-    """
-    Efficiently gets counts using SQL func.count.
-    """
-    
-    # Use func.count for direct SQL COUNT(*), which is instant
-    total_messages_q = await db.execute(
-        select(func.count(models.Message.id))
-        .where(models.Message.chat_id == chat_id)
-    )
-    total_messages = total_messages_q.scalar_one()
-
-    scored_msgs_q = await db.execute(
-        select(func.count(models.MessageSentiment.id))
-        .join(models.Message)
-        .where(models.Message.chat_id == chat_id)
-    )
-    total_messages_scored = scored_msgs_q.scalar_one()
-
-    total_segments_q = await db.execute(
-        select(func.count(models.SenderSegment.id))
-        .join(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-    )
-    total_segments = total_segments_q.scalar_one()
-
-    scored_segments_q = await db.execute(
-        select(func.count(models.SegmentSentiment.id))
-        .join(models.SenderSegment)
-        .join(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-    )
-    total_segments_scored = scored_segments_q.scalar_one()
-
-    return {
-        "messages_total": total_messages,
-        "messages_scored": total_messages_scored,
-        "segments_total": total_segments,
-        "segments_scored": total_segments_scored
-    }
-
-async def get_chat_message_sentiments(db: AsyncSession, chat_id: int) -> Optional[List[models.MessageSentiment]]:
-    stmt = select(models.MessageSentiment).join(models.Message).where(
-        models.Message.chat_id == chat_id
-    )
-    result = await db.execute(stmt)
-
-    return result.scalars().all()
-
-async def get_segments_for_summarization(
-    db: AsyncSession, chat_id: int
-) -> List[models.TimeSegment]:
-    """
-    Fetches all TimeSegments for a specific chat that do not 
-    yet have a summary.
-    
-    This function is optimized to EAGERLY load the related
-    'sender_segments' for each TimeSegment in a single batch, 
-    preventing the N+1 query problem in the summary service.
-    """
-    
-    # 1. Define the query
-    stmt = (
-        select(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-        .where(models.TimeSegment.summary == None)  # <-- Finds work to do
-        .options(
-            selectinload(models.TimeSegment.sender_segments) # <-- The EFFICIENT part
-        )
-        .order_by(models.TimeSegment.start_time) # Process segments in order
-    )
-    
-    # 2. Execute the query
-    result = await db.execute(stmt)
-    
-    # 3. Return the TimeSegment objects
-    # .scalars() gets the TimeSegment objects
-    # .all() executes and returns the list
-    segments = result.scalars().all()
-    
-    return segments
-
-
-async def get_chat_segment_sentiments(db: AsyncSession, chat_id: int) -> Optional[List[models.SegmentSentiment]]:
-    stmt = select(models.SegmentSentiment).join(models.SenderSegment).join(
-        models.TimeSegment
-    ).where(
-        models.TimeSegment.chat_id == chat_id
-    )
-
-    result = await db.execute(stmt)
-    return result.scalars().all()
-
-async def get_sentiment_by_message(db: AsyncSession, message_id: int) -> Optional[schemas.SentimentRead]:
-    result = await db.execute(select(
-        models.MessageSentiment
-    )
-    .where(models.MessageSentiment.message_id == message_id)
-    )
-
-    if result:
-        return result.scalars().first()
-    return None
-
-async def get_sentiment_by_segment(db: AsyncSession, segment_id: int) -> Optional[schemas.SentimentRead]:
-    result = await db.execute(
-        select(
-            models.SegmentSentiment
-        )
-        .where(models.SegmentSentiment.sender_segment_id == segment_id)
-    )
-    if result: return result.scalars().first()
-    return None
-
-# Ingest Cleaned Chat
-async def ingest_cleaned_chat(
-    db: AsyncSession,
-    owner_id: uuid.UUID,
-    chat_name: str,
-    cleaned_messages: List["CleanedMessage"],
-    segments_list: List[dict]
-) -> models.Chat:
-    try:
-        # Create chat
-        chat = await create_chat(db, owner_id=owner_id, title=chat_name, should_commit=False)
-
-        # Insert participants
-        all_chat_participants = {m.sender for m in cleaned_messages if m.sender}
-        participants = await bulk_insert_participants(
-            db=db,
-            chat_id=chat.id,
-            names=all_chat_participants,
-            should_commit=False
-        )
-
-        participants_map = {p.name: p.id for p in participants}
-
-        # Insert time and sender segments (batched)
-        await bulk_insert_segments(
-            db=db,
-            chat_id=chat.id,
-            participants_map=participants_map,
-            time_segments_list=segments_list
-        )
-        # Insert messages in bulk (batched)
-        # We must compute analytics for each message first
-        message_dicts = []
-        for msg in cleaned_messages:
-            # Skip messages without a sender (e.g., system messages)
-            if not msg.sender:
-                continue
-            
-            # Compute analytics, just like in create_message
-            analytics = compute_message_analytics(msg.text)
-            
-            message_dicts.append(
-                {
-                    "chat_id": chat.id,
-                    "participant_id": participants_map.get(msg.sender),
-                    "timestamp": msg.timestamp,
-                    "content": msg.text,
-                    # Match the logic from create_message: use content if raw is missing
-                    "raw": getattr(msg, "raw", None) or msg.text,
-                    
-                    # Add the missing analytics fields
-                    "word_count": analytics['word_count'],
-                    "emojis_count": analytics['emojis_count'],
-                    "links_count": analytics['links_count'],
-                    "is_question": analytics['is_question'],
-                    "is_media": analytics['is_media']
-                }
-            )
-
-        await bulk_insert_messages(db, message_dicts, should_commit=False)
-
-        # Mark chat status
-        chat.sentiment_status = "pending"
-
-        # Single final commit
-        await db.commit()
-        await db.refresh(chat)
-        return chat
-
-    except Exception:
-        await db.rollback()
-        raise
-async def get_unscored_messages(
-        db: AsyncSession,
-        chat_id: int,
-        limit: Optional[int] = None
-):
-    q = await db.execute(
-        select(models.Message)
-        .where(models.Message.chat_id==chat_id)
-            .outerjoin(models.MessageSentiment)
-            .where(models.MessageSentiment.id == None)
-    )
-
-    res = q.scalars().all()
-
-    return res if limit is None else res[:limit]
-
-async def get_unscored_sender_segments(
-        db: AsyncSession,
-        chat_id: int
-):
-    q = await db.execute(
-        select(models.SenderSegment).join(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-        .outerjoin(models.SegmentSentiment)
-        .where(models.SegmentSentiment.id == None)
-    )
-
-    res = q.scalars().all()
-
-    return res
-
-
-def _get_filtered_query(
-    chat_id: int,
-    date_from: Optional[date] = None,
-    date_to: Optional[date] = None,
-    participant_names: Optional[List[str]] = None,
-    time_period: Optional[str] = None
-):
-    stmt = select(models.Message).where(models.Message.chat_id == chat_id)
-
-    if date_from:
-        stmt = stmt.where(func.date(models.Message.timestamp) >= date_from)
-    if date_to:
-        stmt = stmt.where(func.date(models.Message.timestamp) <= date_to)
-    if participant_names:
-        stmt = stmt.join(models.Participant).where(models.Participant.name.in_(participant_names))
-    if time_period and time_period in TIME_PERIOD_BUCKETS:
-        hours = TIME_PERIOD_BUCKETS[time_period]
-        stmt = stmt.where(func.extract('hour', models.Message.timestamp).in_(hours))
-
-    return stmt
-
-
-# --- REFACTORED STREAMING FUNCTION ---
-async def stream_unscored_messages(
-    db: AsyncSession,
-    chat_id: int
-) -> AsyncGenerator[models.Message, None]:
-    """
-    Streams unscored messages one by one using a server-side cursor.
-    This avoids loading all messages into memory.
-    """
-    stmt = (
-        select(models.Message)
-        .where(models.Message.chat_id == chat_id)
-        .outerjoin(models.MessageSentiment)
-        .where(models.MessageSentiment.id == None)
-        .order_by(models.Message.timestamp) # Good practice to have an order
-    )
-    
-    stream = await db.stream_scalars(stmt)
-    async for msg in stream:
-        yield msg
-
-# --- REFACTORED STREAMING FUNCTION ---
-async def stream_unscored_sender_segments(
-    db: AsyncSession,
-    chat_id: int
-) -> AsyncGenerator[models.SenderSegment, None]:
-    """
-    Streams unscored sender segments one by one.
-    """
-    stmt = (
-        select(models.SenderSegment)
-        .join(models.TimeSegment)
-        .where(models.TimeSegment.chat_id == chat_id)
-        .outerjoin(models.SegmentSentiment)
-        .where(models.SegmentSentiment.id == None)
-    )
-    
-    stream = await db.stream_scalars(stmt)
-    async for seg in stream:
-        yield seg

src/app/db/base.py

@@ -1,3 +0,0 @@
-from sqlalchemy.orm import declarative_base
-
-Base = declarative_base()

src/app/db/session.py

@@ -1,58 +0,0 @@
-from typing import AsyncGenerator
-from sqlalchemy.ext.asyncio import (
-    AsyncSession, 
-    create_async_engine, 
-    async_sessionmaker
-)
-
-
-from sqlalchemy.pool import NullPool, QueuePool
-import os
-
-from src.app.config import settings
-import logging
-
-
-logging.getLogger('sqlalchemy.engine').setLevel(logging.WARNING)
-logging.getLogger('sqlalchemy.pool').setLevel(logging.WARNING)
-
-DATABASE_URL = str(settings.DATABASE_URL)
-
-IS_CELERY_WORKER = os.getenv("IS_CELERY_WORKER", "false").lower() == "true"
-
-engine_args = {
-    "echo": False,
-    "echo_pool": False,
-    "logging_name": 'sqlalchemy.engine',
-    "pool_pre_ping": True,
-}
-
-if IS_CELERY_WORKER:
-    engine_args["poolclass"] = NullPool
-else:
-    engine_args["pool_size"] = 10
-    engine_args["max_overflow"] = 0
-    engine_args["pool_timeout"] = 30
-    engine_args["pool_recycle"] = 3600
-
-engine = create_async_engine(
-    DATABASE_URL,
-
-    **engine_args               
-)
-
-
-AsyncSessionLocal = async_sessionmaker(
-    bind=engine,
-    class_=AsyncSession,
-    autoflush=False,
-    autocommit=False,
-    expire_on_commit=False,
-)
-
-async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """
-    Dependency injection to get a new async session.
-    """
-    async with AsyncSessionLocal() as session:
-        yield session

src/app/limiter.py

@@ -1,4 +0,0 @@
-from slowapi import Limiter
-from slowapi.util import get_remote_address
-
-limiter = Limiter(key_func=get_remote_address)

src/app/logging_config.py

@@ -1,42 +0,0 @@
-import logging.config
-
-LOGGING_CONFIG = {
-    "version": 1,
-    "disable_existing_loggers": False,
-    "formatters": {
-        "standard": {
-            "format": "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
-        },
-    },
-    "handlers": {
-        "default": {
-            "level": "INFO",
-            "formatter": "standard",
-            "class": "logging.StreamHandler",
-            "stream": "ext://sys.stdout",
-        },
-        "sqlalchemy": {
-            "level": "WARNING",
-            "formatter": "standard",
-            "class": "logging.StreamHandler",
-            "stream": "ext://sys.stdout",
-        }
-    },
-    "loggers": {
-        "": {  # Root logger
-            "handlers": ["default"],
-            "level": "INFO",
-            "propagate": True
-        },
-        "sqlalchemy.engine": {
-            "handlers": ["sqlalchemy"],
-            "level": "WARNING",
-            "propagate": False
-        },
-        "sqlalchemy.pool": {
-            "handlers": ["sqlalchemy"],
-            "level": "WARNING",
-            "propagate": False
-        }
-    }
-}

src/app/main.py

@@ -1,211 +0,0 @@
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse
-from fastapi.exceptions import RequestValidationError
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.trustedhost import TrustedHostMiddleware
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.middleware import Middleware
-from slowapi.errors import RateLimitExceeded
-from slowapi import _rate_limit_exceeded_handler
-from contextlib import asynccontextmanager
-from fastapi.responses import JSONResponse
-from fastapi import Request
-from sqlalchemy.exc import SQLAlchemyError
-import asyncio
-import logging
-import socket
-import uuid
-import time
-from typing import Callable
-
-
-from src.app.config import settings, setup_logging
-from src.app.db.session import engine  
-from src.app.routers import auth, uploads, chats, sentiment_sse, dashboard, sentiment_dashboard, rag
-from src.app.limiter import limiter
-setup_logging()
-logger = logging.getLogger(__name__)
-APP_VERSION = "v1"
-
-
-class RequestIDMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next: Callable):
-        request_id = request.headers.get("X-Request-ID") or str(uuid.uuid4())
-        request.state.request_id = request_id
-        start = time.time()
-        try:
-            response = await call_next(request)
-        except Exception:
-
-            logger.exception("Unhandled error during request %s %s", request.method, request.url)
-            raise
-        process_time = (time.time() - start) * 1000
-        response.headers["X-Request-ID"] = request_id
-        response.headers["X-Process-Time-ms"] = f"{process_time:.2f}"
-        logger.info("%s %s %s -> %s (%.2fms) [rid=%s]",
-                    request.client.host if request.client else "-",
-                    request.method, request.url.path,
-                    getattr(response, "status_code", "-"), process_time, request_id)
-        return response
-
-
-async def test_db_connection():
-    
-    async with engine.begin() as conn:
-        await conn.run_sync(lambda sync_conn: None) 
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-   
-    logger.info("Starting application: %s", settings.APP_NAME if hasattr(settings, "APP_NAME") else "whatsapp-sentiment")
-
-    if settings.DEBUG and settings.ENVIRONMENT == "production":
-        logger.critical("DEBUG mode is enabled while ENVIRONMENT==production")
-        raise RuntimeError("Invalid configuration: DEBUG cannot be True in production")
-
-    # Validate CORS config early
-    if settings.CORS_ORIGINS == ["*"] and settings.CORS_ALLOW_CREDENTIALS:
-        
-        logger.critical("CORS misconfiguration: allow_origins='*' cannot be used with allow_credentials=True")
-        raise RuntimeError("Invalid CORS configuration: '*' may not be used with credentials")
-
-
-    max_attempts = getattr(settings, "DB_CONNECT_RETRIES", 3)
-    backoff = getattr(settings, "DB_CONNECT_BACKOFF_SECONDS", 2)
-    connected = False
-    last_exc = None
-    for attempt in range(1, max_attempts + 1):
-        try:
-            await test_db_connection()
-            connected = True
-            logger.info("✅ Database connection successful")
-            break
-        except Exception as exc:
-            last_exc = exc
-            logger.warning("Attempt %d/%d - DB connection failed: %s", attempt, max_attempts, exc)
-            await asyncio.sleep(backoff * attempt)
-
-    if not connected:
-        logger.critical("Could not connect to the database after %d attempts. Shutting down.", max_attempts)
-    
-        try:
-            await engine.dispose()
-        except Exception:
-            logger.exception("Error while disposing engine after failed startup")
-
-        raise RuntimeError("Database connection failed")
-    yield
-
-
-    logger.info("Shutting down application gracefully")
-    try:
-        await engine.dispose()
-    except Exception:
-        logger.exception("Failed to dispose DB engine during shutdown")
-
-
-middleware = [
-    Middleware(RequestIDMiddleware),
-    
-    Middleware(TrustedHostMiddleware, allowed_hosts=settings.TRUSTED_HOSTS or ["*"]),
-]
-
-app = FastAPI(title="WhatsApp Sentiment Analysis API", lifespan=lifespan, middleware=middleware)
-
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=settings.CORS_ORIGINS,
-    allow_methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
-    allow_headers=["*"],
-    allow_credentials=getattr(settings, "CORS_ALLOW_CREDENTIALS", True),
-    expose_headers=["X-Request-ID", "X-Process-Time-ms"],
-)
-
-
-@app.exception_handler(HTTPException)
-async def http_exception_handler(request: Request, exc: HTTPException):
-
-    logger.warning("HTTPException (%s) - %s %s - %s", exc.status_code, request.method, request.url, exc.detail)
-    return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
-
-@app.exception_handler(RequestValidationError)
-async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    logger.warning("Validation error for %s %s: %s", request.method, request.url, exc.errors())
-    return JSONResponse(status_code=422, content={"detail": exc.errors()})
-
-@app.exception_handler(OSError)
-async def os_exception_handler(request: Request, exc: OSError):
-
-    if isinstance(exc, socket.gaierror):
-        logger.exception("DNS/host resolution error while handling request %s %s: %s", request.method, request.url, exc)
-        return JSONResponse(status_code=502, content={"detail": "Upstream host resolution failed"})
-    logger.exception("OS error while handling request %s %s", request.method, request.url)
-    return JSONResponse(status_code=500, content={"detail": "Internal server error"})
-
-@app.exception_handler(Exception)
-async def unhandled_exception_handler(request: Request, exc: Exception):
-
-    logger.exception("Unhandled exception for request %s %s", request.method, request.url)
-    return JSONResponse(status_code=500, content={"detail": "Internal server error"})
-
-@app.exception_handler(SQLAlchemyError)
-async def db_exception_handler(request: Request, exc: SQLAlchemyError):
-    """
-    Globally catches Database errors (connection pool exhaustion, timeouts).
-    Returns a 503 Service Unavailable instead of crashing the server.
-    """
-    # Log the full error for your debugging
-    # log.error(f"Database error: {str(exc)}")
-    
-    return JSONResponse(
-        status_code=503,
-        content={
-            "detail": "Service is busy. Database connection limit reached. Please try again in a moment."
-        },
-    )
-
-@app.get("/", tags=["health"])
-async def root():
-    return {"ok": True, "message": "Welcome to the WhatsApp Sentiment Analysis API"}
-
-@app.get("/health/live", tags=["health"])
-async def liveness_probe():
-    return {"status": "alive"}
-
-@app.get("/health/ready", tags=["health"])
-async def readiness_probe():
-
-    try:
-        async with engine.connect() as conn:
-            await conn.execute("SELECT 1")
-    except Exception:
-        logger.exception("Readiness check failed: DB not available")
-        return JSONResponse(status_code=503, content={"status": "unavailable"})
-    return {"status": "ready"}
-
-# -----------------------------------------------------------------------------
-# Include routers
-# -----------------------------------------------------------------------------
-app.include_router(auth.router, prefix=f"/api/{APP_VERSION}/auth", tags=["auth"])
-app.include_router(uploads.router, prefix=f"/api/{APP_VERSION}/uploads", tags=["uploads"])
-app.include_router(chats.router, prefix=f"/api/{APP_VERSION}/chats", tags=["chats"])
-app.include_router(sentiment_sse.router, prefix=f"/api/{APP_VERSION}/sentiment", tags=["sentiment"])
-app.include_router(dashboard.router, prefix=f"/api/{APP_VERSION}/dashboard", tags=["dashboard"])
-app.include_router(sentiment_dashboard.router, prefix=f"/api/{APP_VERSION}/sentiment-dashboard", tags=["Sentiment Dashboard"])
-app.include_router(rag.router, prefix=f"/api/{APP_VERSION}/rag", tags=["RAG Chat"])
-
-
-def _log_startup_banner():
-    masked_db = "(hidden)"
-    try:
-        masked_db = str(settings.DATABASE_URL)[:100] + "..."
-    except Exception:
-        pass
-
-    logger.info("Application startup complete")
-    logger.info("Environment: %s | Debug: %s | CORS origins: %s", settings.ENVIRONMENT, settings.DEBUG, settings.CORS_ORIGINS)
-    logger.info("Database: %s", masked_db)
-

src/app/models.py

@@ -1,329 +0,0 @@
-from datetime import datetime, timezone
-from typing import List, Optional, Dict
-from sqlalchemy import (
-    JSON, Integer, String, DateTime, Text, ForeignKey, Float,
-    UniqueConstraint, Boolean, BigInteger, func, Index
-)
-from sqlalchemy.orm import relationship, Mapped, mapped_column
-import uuid
-from sqlalchemy.dialects.postgresql import UUID
-from src.app.db.base import Base
-from src.app.schemas import SentimentStatusEnum, EmbeddingStatusEnum
-from pgvector.sqlalchemy import Vector
-
-
-class User(Base):
-    __tablename__ = 'users'
-    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
-    chats: Mapped[List["Chat"]] = relationship(
-        "Chat", 
-        back_populates="owner", 
-        lazy="selectin",
-        passive_deletes=True
-    )
-
-class Chat(Base):
-    __tablename__ = "chats"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    title: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True
-    )
-    sentiment_status: Mapped[SentimentStatusEnum] = mapped_column(
-        String(30), nullable=False, default=SentimentStatusEnum.pending.value, index=True
-    )
-    # In your models.py
-
-    embeddings_status: Mapped[EmbeddingStatusEnum] = mapped_column(
-        String(30), 
-        nullable=False, 
-        default=EmbeddingStatusEnum.pending.value,       # Keeps Python logic happy
-        server_default=EmbeddingStatusEnum.pending.value, # <--- ADDS SQL DEFAULT
-        index=True
-    )
-    cancel_requested: Mapped[Optional[bool]] = mapped_column(Boolean, default=False)
-    owner_id: Mapped[uuid.UUID] = mapped_column(
-        ForeignKey("users.id", ondelete="CASCADE"),
-        nullable=False,
-        index=True
-    )
-    messages: Mapped[List["Message"]] = relationship(
-        "Message",
-        back_populates="chat",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    time_segments: Mapped[List["TimeSegment"]] = relationship(
-        "TimeSegment",
-        back_populates="chat",
-        lazy="selectin",
-        passive_deletes=True
-    )
-
-    history: Mapped[List["ConversationHistory"]] = relationship(
-        "ConversationHistory",
-        back_populates="chat",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    owner: Mapped["User"] = relationship(
-        "User", 
-        back_populates="chats",
-        lazy="selectin",
-        passive_deletes=True
-    )
-
-
-class Participant(Base):
-    __tablename__ = "participants"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    chat_id: Mapped[int] = mapped_column(
-        ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True
-    )
-    name: Mapped[str] = mapped_column(String(255), nullable=False)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc), index=True
-    )
-
-    __table_args__ = (UniqueConstraint("chat_id", "name", name="uq_participant_chat_name"),)
-
-    messages: Mapped[List["Message"]] = relationship(
-        "Message",
-        back_populates="participant",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    sender_segments: Mapped[List["SenderSegment"]] = relationship(
-        "SenderSegment",
-        back_populates="participant",
-        lazy="selectin",
-        passive_deletes=True
-    )
-
-
-class Message(Base):
-    __tablename__ = "messages"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    chat_id: Mapped[int] = mapped_column(
-        ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True
-    )
-    participant_id: Mapped[Optional[int]] = mapped_column(
-        ForeignKey("participants.id", ondelete="SET NULL"), nullable=True, index=True
-    )
-    timestamp: Mapped[datetime] = mapped_column(DateTime, nullable=False, index=True)
-    content: Mapped[str] = mapped_column(Text, nullable=False)
-    raw: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-    
-    # Analytics fields
-    word_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-    emojis_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-    links_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
-    is_question: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
-    is_media: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
-
-    chat: Mapped["Chat"] = relationship(
-        "Chat",
-        back_populates="messages",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    participant: Mapped[Optional["Participant"]] = relationship(
-        "Participant",
-        back_populates="messages",
-        lazy="selectin"
-    )
-    sentiment: Mapped[Optional["MessageSentiment"]] = relationship(
-        "MessageSentiment",
-        back_populates="message",
-        uselist=False,
-        lazy="joined",
-        passive_deletes=True
-    )
-
-
-class SenderSegment(Base):
-    __tablename__ = "segments_sender"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    time_segment_id: Mapped[int] = mapped_column(
-        ForeignKey("segments_time.id", ondelete="CASCADE"), nullable=False, index=True
-    )
-    sender_id: Mapped[int] = mapped_column(
-        ForeignKey("participants.id", ondelete="CASCADE"), nullable=False, index=True
-    )
-    message_count: Mapped[int] = mapped_column(Integer, default=0)
-    combined_text: Mapped[str] = mapped_column(Text, nullable=False)
-
-    time_segment: Mapped["TimeSegment"] = relationship(
-        "TimeSegment",
-        back_populates="sender_segments",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    participant: Mapped["Participant"] = relationship(
-        "Participant",
-        back_populates="sender_segments",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    sentiment: Mapped[Optional["SegmentSentiment"]] = relationship(
-        "SegmentSentiment",
-        back_populates="sender_segment",
-        uselist=False,
-        lazy="joined",
-        passive_deletes=True
-    )
-class TimeSegment(Base):
-    __tablename__ = "segments_time"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    chat_id: Mapped[int] = mapped_column(
-        ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True
-    )
-    start_time: Mapped[datetime] = mapped_column(DateTime, nullable=False, index=True)
-    end_time: Mapped[datetime] = mapped_column(DateTime, nullable=False)
-    duration_minutes: Mapped[float] = mapped_column(Float, nullable=False)
-    message_count: Mapped[int] = mapped_column(Integer, default=0)
-    summary: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-
-    chat: Mapped["Chat"] = relationship(
-        "Chat",
-        back_populates="time_segments",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    sender_segments: Mapped[List["SenderSegment"]] = relationship(
-        "SenderSegment",
-        back_populates="time_segment",
-        lazy="selectin",
-        passive_deletes=True
-    )
-    
-
-class MessageSentiment(Base):
-    __tablename__ = "message_sentiments"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    message_id: Mapped[int] = mapped_column(
-        ForeignKey("messages.id", ondelete="CASCADE"),
-        unique=True,
-        nullable=False,
-        index=True
-    )
-    overall_label: Mapped[str] = mapped_column(String(50), nullable=False, index=True)
-    overall_label_score: Mapped[float] = mapped_column(Float, nullable=False, index=True)
-    score_positive: Mapped[Optional[float]] = mapped_column(Float)
-    score_negative: Mapped[Optional[float]] = mapped_column(Float)
-    score_neutral: Mapped[Optional[float]] = mapped_column(Float)
-    sentences_summary: Mapped[Optional[Dict]] = mapped_column(JSON, nullable=True)
-    opinions: Mapped[Optional[Dict]] = mapped_column(JSON, nullable=True)
-    api_version: Mapped[Optional[str]] = mapped_column(String(50))
-    analysis_timestamp: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        default=lambda: datetime.now(timezone.utc),
-        index=True
-    )
-    error_code: Mapped[Optional[str]] = mapped_column(String(100))
-    error_message: Mapped[Optional[str]] = mapped_column(Text)
-
-    message: Mapped["Message"] = relationship(
-        "Message",
-        back_populates="sentiment",
-        lazy="joined",
-        passive_deletes=True
-    )
-
-
-class SegmentSentiment(Base):
-    __tablename__ = "segment_sentiments"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    sender_segment_id: Mapped[int] = mapped_column(
-        ForeignKey("segments_sender.id", ondelete="CASCADE"),
-        unique=True,
-        nullable=False,
-        index=True
-    )
-    overall_label: Mapped[str] = mapped_column(String(50), nullable=False, index=True)
-    overall_label_score: Mapped[float] = mapped_column(Float, nullable=False, index=True)
-    score_positive: Mapped[Optional[float]] = mapped_column(Float)
-    score_negative: Mapped[Optional[float]] = mapped_column(Float)
-    score_neutral: Mapped[Optional[float]] = mapped_column(Float)
-    sentences_summary: Mapped[Optional[Dict]] = mapped_column(JSON, nullable=True)
-    opinions: Mapped[Optional[Dict]] = mapped_column(JSON, nullable=True)
-    api_version: Mapped[Optional[str]] = mapped_column(String(50))
-    analysis_timestamp: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True),
-        default=lambda: datetime.now(timezone.utc),
-        index=True
-    )
-    error_code: Mapped[Optional[str]] = mapped_column(String(100))
-    error_message: Mapped[Optional[str]] = mapped_column(Text)
-
-    sender_segment: Mapped["SenderSegment"] = relationship(
-        "SenderSegment",
-        back_populates="sentiment",
-        lazy="joined",
-        passive_deletes=True
-    )
-
-# Stub table for reference purpose
-class Embedding(Base):
-    __tablename__ = "embeddings"
-
-    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
-    chat_id: Mapped[int] = mapped_column(
-        ForeignKey("chats.id", ondelete="CASCADE"), nullable=False
-    )
-    source_table: Mapped[str] = mapped_column(Text, nullable=False)
-    source_id: Mapped[int] = mapped_column(Integer, nullable=False)
-    
-    embedding: Mapped[List[float]] = mapped_column(Vector(1536), nullable=False) 
-    
-    text_excerpt: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
-    chunk_metadata: Mapped[Optional[dict]] = mapped_column(JSON, default={})
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), server_default=func.now()
-    )
-
-    __table_args__ = (
-        # Match the 'embeddings_chat_id_idx' from your manual migration
-        Index('embeddings_chat_id_idx', 'chat_id'),
-
-        # Match the composite index 'embeddings_chat_source_idx'
-        Index('embeddings_chat_source_idx', 'chat_id', 'source_table', 'source_id'),
-
-        # Match the IVFFlat vector index
-        Index(
-            'embeddings_embedding_ivfflat',
-            'embedding',
-            postgresql_using='ivfflat',
-            postgresql_with={'lists': 100},
-            postgresql_ops={'embedding': 'vector_l2_ops'}
-        ),
-    )
-
-class ConversationHistory(Base):
-    __tablename__ = "conversation_history"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    chat_id: Mapped[int] = mapped_column(
-        ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True
-    )
-    role: Mapped[str] = mapped_column(String(20), nullable=False) # "user" or "assistant"
-    content: Mapped[str] = mapped_column(Text, nullable=False)
-    sources: Mapped[Optional[List[Dict]]] = mapped_column(JSON, nullable=True)
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
-    )
-
-    chat: Mapped["Chat"] = relationship(
-        "Chat",
-        back_populates="history",
-        lazy="selectin",
-        passive_deletes=True
-    )

src/app/routers/auth.py

@@ -1,36 +0,0 @@
-from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-from datetime import datetime, timedelta, timezone
-import jwt
-
-from src.app.config import settings
-from src.app.db.session import get_db
-from src.app import models
-from src.app.security import ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES
-
-router = APIRouter()
-
-@router.post("/guest", response_model=dict)
-async def create_guest_session(db: AsyncSession = Depends(get_db)):
-    """
-    Creates a new anonymous user and returns a long-lived JWT.
-    The frontend should call this ONCE on first load and store the token.
-    """
-    # 1. Create a new Anonymous User
-    new_user = models.User()
-    db.add(new_user)
-    await db.commit()
-    await db.refresh(new_user)
-
-    # 2. GeneratT
-    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    
-    # "sub" holds the User UUID
-    to_encode = {"sub": str(new_user.id), "exp": expire}
-    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
-
-    return {
-        "access_token": encoded_jwt, 
-        "token_type": "bearer",
-        "user_id": str(new_user.id)
-    }

src/app/routers/chats.py

@@ -1,63 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-from  sqlalchemy import select
-import asyncio
-from src.app.config import settings
-from src.app.services.cleanup_service import delete_single_chat_background
-from src.app.db.session import get_db
-from src.app import crud, schemas, models
-from src.app.security import get_current_user
-from src.app.limiter import limiter
-import logging
-log = logging.getLogger(__name__)
-
-router = APIRouter()
-
-@router.delete("/{chat_id}", response_model=dict, status_code=status.HTTP_200_OK)
-@limiter.limit("5/minute")
-async def delete_chat(
-    request: Request, 
-    chat_id: int, 
-    db: AsyncSession = Depends(get_db), 
-    current_user: models.User = Depends(get_current_user)
-):
-    """
-    Delete a chat and all its related data. 
-   
-    """
-    try:
-        
-        stmt = select(models.Chat).where(models.Chat.id == chat_id).with_for_update()
-        result = await db.execute(stmt)
-        chat = result.scalars().first()
-
-        if not chat:
-            # We must commit/rollback to release the implicit transaction lock if we error out
-            await db.rollback() 
-            raise HTTPException(status_code=404, detail="Chat not found")
-
-        # 2. Verify Ownership
-        if chat.owner_id != current_user.id:
-            await db.rollback()
-            raise HTTPException(status_code=404, detail="Chat not found") 
-
-        # 3. Check Status
-        if chat.sentiment_status == "processing":
-            await db.rollback()
-            raise HTTPException(
-                status_code=409,
-                detail="Sentiment analysis is still running. Please cancel the job first."
-            )
-        
-        await db.rollback()  # Release the lock before starting background task
-
-        asyncio.create_task(delete_single_chat_background(chat_id))
-        
-        return {"ok": True, "message": f"Chat {chat_id} deleted successfully"}
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        await db.rollback()
-        log.error(f"Error scheduling delete for chat {chat_id}: {e}")
-        raise HTTPException(status_code=500, detail="Internal server error")

src/app/routers/dashboard.py

@@ -1,83 +0,0 @@
-from datetime import datetime
-from typing import List, Optional
-from fastapi import APIRouter, Depends, Query, HTTPException, Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from src.app.schemas import DashboardData, DashboardFilters
-from src.app.db.session import get_db 
-from src.app import crud, models
-from src.app.services.dashboard_service import get_dashboard_data
-from src.app.security import get_current_user
-from src.app.limiter import limiter
-
-router = APIRouter()
-
-def get_dashboard_filters(
-    start_date: Optional[datetime] = Query(
-        None, 
-        description="Start date for filtering (ISO 8601 format)"
-    ),
-    end_date: Optional[datetime] = Query(
-        None, 
-        description="End date for filtering (ISO 8601 format)"
-    ),
-    participants: Optional[List[str]] = Query(
-        None, 
-        description="List of participant names to include (can be used multiple times)"
-    ),
-    time_period: Optional[str] = Query(
-        None, 
-        description="Time period to filter by",
-        # This enum adds validation and OpenAPI docs for free
-        enum=["Morning", "Afternoon", "Evening", "Night"]
-    )
-) -> DashboardFilters:
-    """
-    Dependency that parses GET query parameters into a
-    DashboardFilters Pydantic model.
-    """
-    return DashboardFilters(
-        start_date=start_date,
-        end_date=end_date,
-        participants=participants,
-        time_period=time_period
-    )
-
-
-# --- Phase 1: Endpoint Definition ---
-
-@router.get(
-    "/chats/{chat_id}",
-    response_model=DashboardData,
-    summary="Get Chat Dashboard Analytics"
-)
-@limiter.limit("20/minute")
-async def read_chat_dashboard(
-    request: Request,
-    chat_id: int,
-    db: AsyncSession = Depends(get_db),
-    filters: DashboardFilters = Depends(get_dashboard_filters),
-    current_user: models.User = Depends(get_current_user)
-):
-    """
-    Retrieve a comprehensive analytics dashboard for a specific chat.
-    
-    This endpoint provides all data necessary to populate the dashboard,
-    with optional filters for:
-    
-    - **Date Range**: `start_date` and `end_date`
-    - **Participants**: `participants` (e.g., ?participants=User+A&participants=User+B)
-    - **Time of Day**: `time_period`
-    """
-    
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat or chat.owner_id != current_user.id:
-        raise HTTPException(status_code=404, detail="Chat not found")
-    
-    dashboard_data = await get_dashboard_data(chat_id=chat_id, db=db, filters=filters)
-    
-    if not dashboard_data:
-        # The service will return None if the chat_id doesn't exist
-        raise HTTPException(status_code=404, detail="Chat not found or no data available.")
-        
-    return dashboard_data

src/app/routers/rag.py

@@ -1,120 +0,0 @@
-import logging
-from fastapi import APIRouter, Depends, HTTPException, Request
-from fastapi.responses import StreamingResponse, JSONResponse
-from sqlalchemy.ext.asyncio import AsyncSession
-from langchain_core.messages import HumanMessage, AIMessage
-from sqlalchemy import select
-from typing import List, Optional
-from src.app.db.session import get_db
-from src.app import crud, models
-from src.app.schemas import RagQueryRequest, ConversationHistoryItem
-from src.app.security import get_current_user
-from src.app.services import router_service
-from src.app.limiter import limiter
-
-router = APIRouter()
-log = logging.getLogger(__name__)
-
-# --- NEW ENDPOINT START ---
-@router.get("/chat/{chat_id}/status")
-async def get_chat_status(
-    chat_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: models.User = Depends(get_current_user)
-):
-    # Single query to check ownership AND get status at the same time
-    # This prevents double DB hits (one for auth, one for status)
-    query = select(models.Chat.embeddings_status).where(
-        models.Chat.id == chat_id,
-        models.Chat.owner_id == current_user.id
-    )
-    result = await db.execute(query)
-    status = result.scalar_one_or_none()
-
-    if status is None:
-        raise HTTPException(status_code=404, detail="Chat not found")
-    
-    return JSONResponse(content={"status": status})
-
-
-@router.post(
-    "/chat/{chat_id}/query/streamed"
-)
-@limiter.limit("5/minute")
-async def query_chat_streamed(
-    request: Request,
-    chat_id: int,
-    payload: RagQueryRequest,
-    db: AsyncSession = Depends(get_db),
-    current_user: models.User = Depends(get_current_user)
-):
-    """
-    Main endpoint for asking questions to a chat (Streaming).
-    """
-
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat or chat.owner_id != current_user.id:
-        raise HTTPException(status_code=404, detail="Chat not found")
-
-    
-    
-    history_objs = await crud.get_conversation_history(db, chat_id, limit=6)
-    chat_history_messages = []
-    for h in history_objs:
-        if h.role == "user":
-            chat_history_messages.append(HumanMessage(content=h.content))
-        else:
-            chat_history_messages.append(AIMessage(content=h.content))
-
-    analytics_data = payload.analytics_json or {}
-    return StreamingResponse(
-        router_service.route_and_process(
-            query=payload.question,
-            analytics_json=analytics_data,
-            chat_id=chat_id,
-            db=db,
-            chat_history=chat_history_messages
-        ),
-        media_type="text/event-stream"
-    )
-
-
-
-
-
-@router.delete("/chat/{chat_id}/history", status_code=204)
-@limiter.limit("10/minute")
-async def clear_chat_history(
-    request: Request,
-    chat_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: models.User = Depends(get_current_user)
-):
-    """
-    Clears the conversation memory for this chat.
-    """
-
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat or chat.owner_id != current_user.id:
-        raise HTTPException(status_code=404, detail="Chat not found")
-
-
-    await crud.clear_conversation_history(db, chat_id)
-    
-    return 
-
-@router.get(
-    "/chat/{chat_id}/history",
-    response_model=List[ConversationHistoryItem]
-)
-async def get_chat_history(
-    chat_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: models.User = Depends(get_current_user)
-):
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat or chat.owner_id != current_user.id:
-        raise HTTPException(status_code=404, detail="Chat not found")
-    
-    history = await crud.get_full_conversation_history(db, chat_id)
-    return history

src/app/routers/rag_streamed.py

@@ -1,75 +0,0 @@
-# src/app/routers/rag.py
-
-import logging
-from fastapi import APIRouter, Depends, HTTPException
-
-from sqlalchemy.ext.asyncio import AsyncSession
-from typing import List
-from src.app.db.session import get_db
-from src.app import crud
-from src.app.schemas import RagQueryRequest, RagQueryResponse
-from src.app.services import rag_service_prev
-from src.app.schemas import ConversationHistoryItem
-
-router = APIRouter()
-log = logging.getLogger(__name__)
-
-@router.post(
-    "/chat/{chat_id}/query",
-    response_model=RagQueryResponse
-)
-async def query_chat(
-    chat_id: int,
-    payload: RagQueryRequest,
-    db: AsyncSession = Depends(get_db)
-):
-    """
-    Main endpoint for asking questions to a chat.
-
-    """
-
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat:
-        raise HTTPException(status_code=404, detail="Chat not found")
-    
-   
-    try:
-        response = await rag_service_prev.process_rag_query(chat_id, payload)
-        return response
-    except Exception as e:
-        log.error(f"RAG endpoint failed for chat {chat_id}: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Error processing your question.")
-
-
-@router.delete("/chat/{chat_id}/history", status_code=204)
-async def clear_chat_history(
-    chat_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    """
-    Clears the conversation memory for this chat.
-    """
-
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat:
-        raise HTTPException(status_code=404, detail="Chat not found")
-
-
-    await crud.clear_conversation_history(db, chat_id)
-    
-    return 
-
-@router.get(
-    "/chat/{chat_id}/history",
-    response_model=List[ConversationHistoryItem]
-)
-async def get_chat_history(
-    chat_id: int,
-    db: AsyncSession = Depends(get_db)
-):
-    chat = await crud.get_chat(db, chat_id=chat_id)
-    if not chat:
-        raise HTTPException(status_code=404, detail="Chat not found")
-    
-    history = await crud.get_full_conversation_history(db, chat_id)
-    return history