Update database layer and application logic for db interaction to be async

pyproject.toml

@@ -6,9 +6,11 @@ readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "anthropic>=0.45.2",
+    "asyncpg>=0.28.0", 
     "elevenlabs>=1.50.7",
     "gradio>=5.15.0",
-    "psycopg2>=2.9.0",
+    "greenlet>=2.0.0",
+    "httpx>=0.24.1",
     "python-dotenv>=1.0.1",
     "requests>=2.32.3",
     "sqlalchemy>=2.0.0",

src/app.py

@@ -9,6 +9,8 @@ Users can compare the outputs and vote for their favorite in an interactive UI.
 """
 
 # Standard Library Imports
+import asyncio
+import threading
 import time
 from concurrent.futures import ThreadPoolExecutor
 from typing import Tuple
@@ -20,7 +22,7 @@ import gradio as gr
 from src import constants
 from src.config import Config, logger
 from src.custom_types import Option, OptionMap
-from src.database.database import DBSessionMaker
+from src.database.database import AsyncDBSessionMaker
 from src.integrations import (
     AnthropicError,
     ElevenLabsError,
@@ -41,9 +43,9 @@ from src.utils import (
 
 class App:
     config: Config
-    db_session_maker: DBSessionMaker
+    db_session_maker: AsyncDBSessionMaker
 
-    def __init__(self, config: Config, db_session_maker: DBSessionMaker):
+    def __init__(self, config: Config, db_session_maker: AsyncDBSessionMaker):
         self.config = config
         self.db_session_maker = db_session_maker
 
@@ -188,6 +190,47 @@ class App:
             logger.error(f"Unexpected error during TTS generation: {e}")
             raise gr.Error("An unexpected error occurred. Please try again later.")
 
+
+    def _background_submit_vote(
+        self,
+        option_map: OptionMap,
+        selected_option: constants.OptionKey,
+        text_modified: bool,
+        character_description: str,
+        text: str,
+    ) -> None:
+        """
+        Runs the vote submission in a background thread.
+        Creates a new event loop and runs the async submit_voting_results function in it.
+
+        Args:
+            Same as submit_voting_results
+
+        Returns:
+            None
+        """
+        try:
+            # Create a new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            # Run the async function in the new loop
+            loop.run_until_complete(submit_voting_results(
+                option_map,
+                selected_option,
+                text_modified,
+                character_description,
+                text,
+                self.db_session_maker,
+                self.config,
+            ))
+        except Exception as e:
+            logger.error(f"Error in background vote submission thread: {e}", exc_info=True)
+        finally:
+            # Close the loop when done
+            loop.close()
+
+
     def _vote(
         self,
         vote_submitted: bool,
@@ -203,19 +246,14 @@ class App:
         Args:
             vote_submitted (bool): True if a vote was already submitted.
             option_map (OptionMap): A dictionary mapping option labels to their details.
-                Expected structure:
-                {
-                    'Option A': 'Hume AI',
-                    'Option B': 'ElevenLabs',
-                }
             clicked_option_button (str): The button that was clicked.
 
         Returns:
             A tuple of:
-             - A boolean indicating if the vote was accepted.
-             - A dict update for the selected vote button (showing provider and trophy emoji).
-             - A dict update for the unselected vote button (showing provider).
-             - A dict update for enabling vote interactions.
+            - A boolean indicating if the vote was accepted.
+            - A dict update for the selected vote button (showing provider and trophy emoji).
+            - A dict update for the unselected vote button (showing provider).
+            - A dict update for enabling vote interactions.
         """
         if not option_map or vote_submitted:
             return gr.skip(), gr.skip(), gr.skip(), gr.skip()
@@ -224,16 +262,19 @@ class App:
         selected_provider = option_map[selected_option]["provider"]
         other_provider = option_map[other_option]["provider"]
 
-        # Report voting results to be persisted to results DB.
-        submit_voting_results(
-            option_map,
-            selected_option,
-            text_modified,
-            character_description,
-            text,
-            self.db_session_maker,
-            self.config,
+        # Start a background thread for the database operation
+        thread = threading.Thread(
+            target=self._background_submit_vote,
+            args=(
+                option_map,
+                selected_option,
+                text_modified,
+                character_description,
+                text,
+            ),
+            daemon=True
         )
+        thread.start()
 
         # Build button text, displaying the provider and voice name, appending the trophy emoji to the selected option.
         selected_label = f"{selected_provider} {constants.TROPHY_EMOJI}"

src/database/__init__.py

@@ -1,9 +1,9 @@
 from .crud import create_vote
-from .database import Base, DBSessionMaker, engine, init_db
+from .database import AsyncDBSessionMaker, Base, engine, init_db
 
 __all__ = [
+    "AsyncDBSessionMaker",
     "Base",
-    "DBSessionMaker",
     "create_vote",
     "engine",
     "init_db",

src/database/crud.py

@@ -6,19 +6,19 @@ Since vote records are never updated or deleted, only functions to create and re
 """
 
 # Third-Party Library Imports
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
 
 # Local Application Imports
 from src.custom_types import VotingResults
 from src.database.models import VoteResult
 
 
-def create_vote(db: Session, vote_data: VotingResults) -> VoteResult:
+async def create_vote(db: AsyncSession, vote_data: VotingResults) -> VoteResult:
     """
     Create a new vote record in the database based on the given VotingResults data.
 
     Args:
-        db (Session): The SQLAlchemy database session.
+        db (AsyncSession): The SQLAlchemy async database session.
         vote_data (VotingResults): The vote data to persist.
 
     Returns:
@@ -38,9 +38,9 @@ def create_vote(db: Session, vote_data: VotingResults) -> VoteResult:
     )
     db.add(vote)
     try:
-        db.commit()
+        await db.commit()
     except Exception as e:
-        db.rollback()
+        await db.rollback()
         raise e
-    db.refresh(vote)
+    await db.refresh(vote)
     return vote

src/database/database.py

@@ -12,8 +12,8 @@ If no DATABASE_URL environment variable is set, then create a dummy database to
 from typing import Callable, Optional
 
 # Third-Party Library Imports
-from sqlalchemy import Engine, create_engine
-from sqlalchemy.orm import DeclarativeBase, sessionmaker
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
 
 # Local Application Imports
 from src.config import Config
@@ -24,44 +24,44 @@ class Base(DeclarativeBase):
     pass
 
 
-engine: Optional[Engine] = None
+engine: Optional[AsyncEngine] = None
 
 
-class DummySession:
+class AsyncDummySession:
     is_dummy = True  # Flag to indicate this is a dummy session.
 
-    def __enter__(self):
+    async def __enter__(self):
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    async def __exit__(self, exc_type, exc_value, traceback):
         pass
 
-    def add(self, _instance, _warn=True):
+    async def add(self, _instance, _warn=True):
         # No-op: simply ignore adding the instance.
         pass
 
-    def commit(self):
+    async def commit(self):
         # Raise an exception to simulate failure when attempting a write.
         raise RuntimeError("DummySession does not support commit operations.")
 
-    def refresh(self, _instance):
+    async def refresh(self, _instance):
         # Raise an exception to simulate failure when attempting to refresh.
         raise RuntimeError("DummySession does not support refresh operations.")
 
-    def rollback(self):
+    async def rollback(self):
         # No-op: there's nothing to roll back.
         pass
 
-    def close(self):
+    async def close(self):
         # No-op: nothing to close.
         pass
 
 
-# DBSessionMaker is either a sessionmaker instance or a callable that returns a DummySession.
-DBSessionMaker = sessionmaker | Callable[[], DummySession]
+# AsyncDBSessionMaker is either a async_sessionmaker instance or a callable that returns a AsyncDummySession.
+AsyncDBSessionMaker = async_sessionmaker | Callable[[], AsyncDummySession]
 
 
-def init_db(config: Config) -> DBSessionMaker:
+def init_db(config: Config) -> AsyncDBSessionMaker:
     """
     Initialize the database engine and return a session factory based on the provided configuration.
 
@@ -72,27 +72,37 @@ def init_db(config: Config) -> DBSessionMaker:
         config (Config): The application configuration.
 
     Returns:
-        DBSessionMaker: A sessionmaker bound to the engine, or a dummy session factory.
+        AsyncDBSessionMaker: A sessionmaker bound to the engine, or a dummy session factory.
     """
     # ruff doesn't like setting global variables, but this is practical here
     global engine  # noqa
 
+    # Convert standard PostgreSQL URL to async format
+    def convert_to_async_url(url: str) -> str:
+        # Convert postgresql:// to postgresql+asyncpg://
+        if url.startswith('postgresql://'):
+            return url.replace('postgresql://', 'postgresql+asyncpg://', 1)
+        return url
+
     if config.app_env == "prod":
         # In production, a valid DATABASE_URL is required.
         if not config.database_url:
             raise ValueError("DATABASE_URL must be set in production!")
-        engine = create_engine(config.database_url)
-        return sessionmaker(bind=engine)
+        async_db_url = convert_to_async_url(config.database_url)
+        engine = create_async_engine(async_db_url)
+        return async_sessionmaker(bind=engine, expire_on_commit=False, class_=AsyncSession)
 
     # In development, if a DATABASE_URL is provided, use it.
     if config.database_url:
-        engine = create_engine(config.database_url)
-        return sessionmaker(bind=engine)
+        async_db_url = convert_to_async_url(config.database_url)
+        engine = create_async_engine(async_db_url)
+        return async_sessionmaker(bind=engine, expire_on_commit=False, class_=AsyncSession)
 
     # No DATABASE_URL is provided; use a DummySession that does nothing.
     engine = None
 
-    def dummy_session_factory() -> DummySession:
-        return DummySession()
+    def async_dummy_session_factory() -> AsyncDummySession:
+        return AsyncDummySession()
+
+    return async_dummy_session_factory
 
-    return dummy_session_factory

src/integrations/anthropic_api.py

@@ -44,8 +44,6 @@ Your absolute priority is delivering complete, untruncated responses within stri
   words. NEVER include newlines in the output
 - Make sure that all responses are complete thoughts, not fragments, and have clear beginnings and endings
 - The text must sound human-like, prosodic, expressive, conversational. Avoid generic AI-like words like "delve".
-- Use the utterances "uh", "um", "hm", "woah", or "like" for expressivity in conversational text. Use these naturally
-  within the sentence. Never use them at the very end of a sentence.
 - Avoid any short utterances at the end of the sentence - like ", hm?" or "oh" at the end. Avoid these short, isolated
   utterances because they are difficult for our TTS system to speak.
 - Avoid words that are overly long, very rare, or difficult to pronounce. For example, avoid "eureka", or "schnell",

src/scripts/init_db.py

@@ -2,19 +2,55 @@
 init_db.py
 
 This script initializes the database by creating all tables defined in the ORM models.
-Run this script once to create your tables in the PostgreSQL database.
+It uses async SQLAlchemy operations to create tables in the PostgreSQL database.
+Run this script once to set up your database schema.
 """
 
+# Standard Library Imports
+import asyncio
+
 # Local Application Imports
-from src.config import logger
+from src.config import Config, logger
 from src.database.database import engine
 from src.database.models import Base
 
 
-def init_db():
-    Base.metadata.create_all(bind=engine)
-    logger.info("Database tables created successfully.")
+async def init_db_async():
+    """
+    Asynchronously create all database tables defined in the ORM models.
+
+    This function connects to the database using the configured async engine
+    and creates all tables that are mapped to SQLAlchemy models derived from
+    the Base class. It uses SQLAlchemy's create_all method with the async
+    engine context.
+
+    Returns:
+        None
+    """
+    async with engine.begin() as conn:
+        # In SQLAlchemy 2.0 with async, we use the connection directly
+        await conn.run_sync(Base.metadata.create_all)
+
+    logger.info("Database tables created successfully using async SQLAlchemy.")
+
+
+def main():
+    """
+    Main entry point for the database initialization script.
+
+    This function creates the configuration, ensures the async engine is 
+    initialized, and runs the async initialization function within an
+    event loop.
+
+    Returns:
+        None
+    """
+    # Make sure config is loaded first to initialize the engine
+    Config.get()
+
+    # Run the async initialization function
+    asyncio.run(init_db_async())
 
 
 if __name__ == "__main__":
-    init_db()
+    main()

src/scripts/test_db.py

@@ -2,11 +2,12 @@
 test_db.py
 
 This script verifies the database connection for the Expressive TTS Arena project.
-It attempts to connect to the PostgreSQL database using SQLAlchemy and executes a simple query.
+It attempts to connect to the PostgreSQL database using async SQLAlchemy and executes 
+a simple query to confirm connectivity.
 
 Functionality:
 - Loads the database connection from `database.py`.
-- Attempts to establish a connection to the database.
+- Attempts to establish an async connection to the database.
 - Executes a test query (`SELECT 1`) to confirm connectivity.
 - Prints a success message if the connection is valid.
 - Prints an error message if the connection fails.
@@ -22,33 +23,73 @@ Troubleshooting:
 - Ensure the `.env` file contains a valid `DATABASE_URL`.
 - Check that the database server is running and accessible.
 - Verify PostgreSQL credentials and network settings.
-
 """
 
 # Standard Library Imports
+import asyncio
 import sys
 
 # Third-Party Library Imports
 from sqlalchemy import text
-from sqlalchemy.exc import OperationalError
 
 # Local Application Imports
-from src.config import logger
-from src.database import engine
+from src.config import Config, logger
+from src.database.database import engine, init_db
+
+
+async def test_connection_async():
+    """
+    Asynchronously test the database connection.
 
+    This function attempts to connect to the database using the configured
+    async engine and execute a simple SELECT query. It logs success or failure
+    messages accordingly.
 
-def main() -> None:
+    Returns:
+        bool: True if the connection was successful, False otherwise.
+    """
     if engine is None:
         logger.error("No valid database engine configured.")
-        sys.exit(1)
+        return False
 
     try:
-        with engine.connect() as conn:
-            conn.execute(text("SELECT 1"))
-            logger.info("Database connection successful!")
-    except OperationalError as e:
-        logger.error(f"Database connection failed: {e}")
-        sys.exit(1)
+        # Create a new async session
+        async with engine.connect() as conn:
+            # Execute a simple query to verify connectivity
+            result = await conn.execute(text("SELECT 1"))
+            # Fetch the result to make sure the query completes
+            await result.fetchone()
+
+        logger.info("Async database connection successful!")
+        return True
+
+    except Exception as e:
+        logger.error(f"Async database connection failed: {e}")
+        return False
+
+
+def main():
+    """
+    Main entry point for the database connection test script.
+
+    This function creates the configuration, initializes the database engine,
+    and runs the async test function within an event loop. It exits with an
+    appropriate system exit code based on the test result.
+
+    Returns:
+        None
+    """
+    # Make sure config is loaded first to initialize the engine
+    config = Config.get()
+
+    # Initialize the database engine
+    init_db(config)
+
+    # Run the async test function
+    success = asyncio.run(test_connection_async())
+
+    # Exit with an appropriate status code
+    sys.exit(0 if success else 1)
 
 
 if __name__ == "__main__":

src/utils.py

@@ -14,7 +14,8 @@ import time
 from pathlib import Path
 from typing import Tuple, cast
 
-from sqlalchemy.orm import Session
+# Third-Party Library Imports
+from sqlalchemy.ext.asyncio import AsyncSession
 
 # Local Application Imports
 from src import constants
@@ -28,7 +29,7 @@ from src.custom_types import (
     VotingResults,
 )
 from src.database import crud
-from src.database.database import DBSessionMaker
+from src.database.database import AsyncDBSessionMaker
 
 
 def truncate_text(text: str, max_length: int = 50) -> str:
@@ -301,107 +302,98 @@ def _log_voting_results(voting_results: VotingResults) -> None:
     logger.info("Voting results:\n%s", json.dumps(voting_results, indent=4))
 
 
-def _handle_vote_failure(
-    e: Exception,
+async def _persist_vote(
+    db_session_maker: AsyncDBSessionMaker,
     voting_results: VotingResults,
-    is_dummy_db_session: bool,
-    config: Config,
+    config: Config
 ) -> None:
     """
-    Handles logging when creating a vote record fails.
-
-    In production (or in dev with a real session):
-      - Logs the error (with full traceback in prod) and the voting results.
-      - In production, re-raises the exception.
-
-    In development with a dummy session:
-      - Only logs the voting results.
-    """
-
-    if config.app_env == "prod" or (config.app_env == "dev" and not is_dummy_db_session):
-        logger.error("Failed to create vote record: %s", e, exc_info=(config.app_env == "prod"))
-        _log_voting_results(voting_results)
-        if config.app_env == "prod":
-            raise e
-    else:
-        # Dev mode with a dummy session: only log the voting results.
-        _log_voting_results(voting_results)
-
-
-def _persist_vote(db_session_maker: DBSessionMaker, voting_results: VotingResults, config: Config) -> None:
-    """
-    Persist a vote record in the database and handle potential failures.
-
-    This function obtains a database session using the provided session maker and attempts
-    to create a vote record using the specified voting results. If the session is identified
-    as a dummy session, it logs a success message and outputs the voting results. If an error
-    occurs during vote creation, the function delegates error handling to _handle_vote_failure.
-    On successful vote creation, it logs the success and, when running in a development environment,
-    logs the full voting results for debugging purposes. In all cases, the database session is
-    properly closed after the operation.
+    Asynchronously persist a vote record in the database and handle potential failures.
+    Designed to work safely in a background task context.
 
     Args:
-        db_session_maker (DBSessionMaker): A callable that returns a new database session.
+        db_session_maker (AsyncDBSessionMaker): A callable that returns a new async database session.
         voting_results (VotingResults): A dictionary containing the details of the vote to persist.
         config (Config): The application configuration, used to determine environment-specific behavior.
+
+    Returns:
+        None
     """
+    # Create session
+    session = db_session_maker()
+    is_dummy_session = getattr(session, "is_dummy", False)
 
-    db = db_session_maker()
-    is_dummy_db_session = getattr(db, "is_dummy", False)
-    if is_dummy_db_session:
+    if is_dummy_session:
         logger.info("Vote record created successfully.")
         _log_voting_results(voting_results)
+        await session.close()
+        return
+
     try:
-        crud.create_vote(cast(Session, db), voting_results)
-    except Exception as e:
-        _handle_vote_failure(e, voting_results, is_dummy_db_session, config)
-    else:
+        await crud.create_vote(cast(AsyncSession, session), voting_results)
         logger.info("Vote record created successfully.")
         if config.app_env == "dev":
             _log_voting_results(voting_results)
+    except Exception as e:
+        # Log the error with traceback in production, without traceback in dev
+        logger.error(f"Failed to create vote record: {e}",
+                     exc_info=(config.app_env == "prod"))
+        _log_voting_results(voting_results)
     finally:
-        db.close()
+        # Always ensure the session is closed
+        await session.close()
 
 
-def submit_voting_results(
+async def submit_voting_results(
     option_map: OptionMap,
     selected_option: OptionKey,
     text_modified: bool,
     character_description: str,
     text: str,
-    db_session_maker: DBSessionMaker,
+    db_session_maker: AsyncDBSessionMaker,
     config: Config,
 ) -> None:
     """
-    Constructs the voting results dictionary from the provided inputs,
-    logs it, persists a new vote record in the database, and returns the record.
+    Asynchronously constructs the voting results dictionary and persists a new vote record.
+    Designed to run as a background task, handling all exceptions internally.
 
     Args:
         option_map (OptionMap): Mapping of comparison data and TTS options.
-        selected_option (str): The option selected by the user.
-        text_modified (bool): Indicates whether the text was modified.
-        character_description (str): Description of the voice/character.
-        text (str): The text associated with the TTS generation.
-    """
+        selected_option (OptionKey): The option selected by the user.
+        text_modified (bool): Indicates whether the text was modified from the original generated text.
+        character_description (str): Description of the voice/character used for TTS generation.
+        text (str): The text that was synthesized into speech.
+        db_session_maker (AsyncDBSessionMaker): Factory function for creating async database sessions.
+        config (Config): Application configuration containing environment settings.
 
-    provider_a: TTSProviderName = option_map[constants.OPTION_A_KEY]["provider"]
-    provider_b: TTSProviderName = option_map[constants.OPTION_B_KEY]["provider"]
-    comparison_type: ComparisonType = _determine_comparison_type(provider_a, provider_b)
-
-    voting_results: VotingResults = {
-        "comparison_type": comparison_type,
-        "winning_provider": option_map[selected_option]["provider"],
-        "winning_option": selected_option,
-        "option_a_provider": provider_a,
-        "option_b_provider": provider_b,
-        "option_a_generation_id": option_map[constants.OPTION_A_KEY]["generation_id"],
-        "option_b_generation_id": option_map[constants.OPTION_B_KEY]["generation_id"],
-        "character_description": character_description,
-        "text": text,
-        "is_custom_text": text_modified,
-    }
+    Returns:
+        None
+    """
+    try:
+        provider_a: TTSProviderName = option_map[constants.OPTION_A_KEY]["provider"]
+        provider_b: TTSProviderName = option_map[constants.OPTION_B_KEY]["provider"]
+
+        comparison_type: ComparisonType = _determine_comparison_type(provider_a, provider_b)
+
+        voting_results: VotingResults = {
+            "comparison_type": comparison_type,
+            "winning_provider": option_map[selected_option]["provider"],
+            "winning_option": selected_option,
+            "option_a_provider": provider_a,
+            "option_b_provider": provider_b,
+            "option_a_generation_id": option_map[constants.OPTION_A_KEY]["generation_id"],
+            "option_b_generation_id": option_map[constants.OPTION_B_KEY]["generation_id"],
+            "character_description": character_description,
+            "text": text,
+            "is_custom_text": text_modified,
+        }
+
+        await _persist_vote(db_session_maker, voting_results, config)
 
-    _persist_vote(db_session_maker, voting_results, config)
+    except Exception as e:
+        # Catch all exceptions at the top level of the background task
+        # to prevent unhandled exceptions in background tasks
+        logger.error(f"Background task error in submit_voting_results: {e}", exc_info=True)
 
 
 def validate_env_var(var_name: str) -> str:

uv.lock

@@ -56,6 +56,38 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/eb/e7f063ad1fec6b3178a3cd82d1a3c4de82cccf283fc42746168188e1cdd5/anyio-4.8.0-py3-none-any.whl", hash = "sha256:b5011f270ab5eb0abf13385f851315585cc37ef330dd88e27ec3d34d651fd47a", size = 96041 },
 ]
 
+[[package]]
+name = "asyncpg"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/4c/7c991e080e106d854809030d8584e15b2e996e26f16aee6d757e387bc17d/asyncpg-0.30.0.tar.gz", hash = "sha256:c551e9928ab6707602f44811817f82ba3c446e018bfe1d3abecc8ba5f3eac851", size = 957746 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/0e/f5d708add0d0b97446c402db7e8dd4c4183c13edaabe8a8500b411e7b495/asyncpg-0.30.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5e0511ad3dec5f6b4f7a9e063591d407eee66b88c14e2ea636f187da1dcfff6a", size = 674506 },
+    { url = "https://files.pythonhosted.org/packages/6a/a0/67ec9a75cb24a1d99f97b8437c8d56da40e6f6bd23b04e2f4ea5d5ad82ac/asyncpg-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:915aeb9f79316b43c3207363af12d0e6fd10776641a7de8a01212afd95bdf0ed", size = 645922 },
+    { url = "https://files.pythonhosted.org/packages/5c/d9/a7584f24174bd86ff1053b14bb841f9e714380c672f61c906eb01d8ec433/asyncpg-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c198a00cce9506fcd0bf219a799f38ac7a237745e1d27f0e1f66d3707c84a5a", size = 3079565 },
+    { url = "https://files.pythonhosted.org/packages/a0/d7/a4c0f9660e333114bdb04d1a9ac70db690dd4ae003f34f691139a5cbdae3/asyncpg-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3326e6d7381799e9735ca2ec9fd7be4d5fef5dcbc3cb555d8a463d8460607956", size = 3109962 },
+    { url = "https://files.pythonhosted.org/packages/3c/21/199fd16b5a981b1575923cbb5d9cf916fdc936b377e0423099f209e7e73d/asyncpg-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:51da377487e249e35bd0859661f6ee2b81db11ad1f4fc036194bc9cb2ead5056", size = 3064791 },
+    { url = "https://files.pythonhosted.org/packages/77/52/0004809b3427534a0c9139c08c87b515f1c77a8376a50ae29f001e53962f/asyncpg-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc6d84136f9c4d24d358f3b02be4b6ba358abd09f80737d1ac7c444f36108454", size = 3188696 },
+    { url = "https://files.pythonhosted.org/packages/52/cb/fbad941cd466117be58b774a3f1cc9ecc659af625f028b163b1e646a55fe/asyncpg-0.30.0-cp311-cp311-win32.whl", hash = "sha256:574156480df14f64c2d76450a3f3aaaf26105869cad3865041156b38459e935d", size = 567358 },
+    { url = "https://files.pythonhosted.org/packages/3c/0a/0a32307cf166d50e1ad120d9b81a33a948a1a5463ebfa5a96cc5606c0863/asyncpg-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:3356637f0bd830407b5597317b3cb3571387ae52ddc3bca6233682be88bbbc1f", size = 629375 },
+    { url = "https://files.pythonhosted.org/packages/4b/64/9d3e887bb7b01535fdbc45fbd5f0a8447539833b97ee69ecdbb7a79d0cb4/asyncpg-0.30.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c902a60b52e506d38d7e80e0dd5399f657220f24635fee368117b8b5fce1142e", size = 673162 },
+    { url = "https://files.pythonhosted.org/packages/6e/eb/8b236663f06984f212a087b3e849731f917ab80f84450e943900e8ca4052/asyncpg-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aca1548e43bbb9f0f627a04666fedaca23db0a31a84136ad1f868cb15deb6e3a", size = 637025 },
+    { url = "https://files.pythonhosted.org/packages/cc/57/2dc240bb263d58786cfaa60920779af6e8d32da63ab9ffc09f8312bd7a14/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c2a2ef565400234a633da0eafdce27e843836256d40705d83ab7ec42074efb3", size = 3496243 },
+    { url = "https://files.pythonhosted.org/packages/f4/40/0ae9d061d278b10713ea9021ef6b703ec44698fe32178715a501ac696c6b/asyncpg-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1292b84ee06ac8a2ad8e51c7475aa309245874b61333d97411aab835c4a2f737", size = 3575059 },
+    { url = "https://files.pythonhosted.org/packages/c3/75/d6b895a35a2c6506952247640178e5f768eeb28b2e20299b6a6f1d743ba0/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0f5712350388d0cd0615caec629ad53c81e506b1abaaf8d14c93f54b35e3595a", size = 3473596 },
+    { url = "https://files.pythonhosted.org/packages/c8/e7/3693392d3e168ab0aebb2d361431375bd22ffc7b4a586a0fc060d519fae7/asyncpg-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db9891e2d76e6f425746c5d2da01921e9a16b5a71a1c905b13f30e12a257c4af", size = 3641632 },
+    { url = "https://files.pythonhosted.org/packages/32/ea/15670cea95745bba3f0352341db55f506a820b21c619ee66b7d12ea7867d/asyncpg-0.30.0-cp312-cp312-win32.whl", hash = "sha256:68d71a1be3d83d0570049cd1654a9bdfe506e794ecc98ad0873304a9f35e411e", size = 560186 },
+    { url = "https://files.pythonhosted.org/packages/7e/6b/fe1fad5cee79ca5f5c27aed7bd95baee529c1bf8a387435c8ba4fe53d5c1/asyncpg-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a0292c6af5c500523949155ec17b7fe01a00ace33b68a476d6b5059f9630305", size = 621064 },
+    { url = "https://files.pythonhosted.org/packages/3a/22/e20602e1218dc07692acf70d5b902be820168d6282e69ef0d3cb920dc36f/asyncpg-0.30.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05b185ebb8083c8568ea8a40e896d5f7af4b8554b64d7719c0eaa1eb5a5c3a70", size = 670373 },
+    { url = "https://files.pythonhosted.org/packages/3d/b3/0cf269a9d647852a95c06eb00b815d0b95a4eb4b55aa2d6ba680971733b9/asyncpg-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c47806b1a8cbb0a0db896f4cd34d89942effe353a5035c62734ab13b9f938da3", size = 634745 },
+    { url = "https://files.pythonhosted.org/packages/8e/6d/a4f31bf358ce8491d2a31bfe0d7bcf25269e80481e49de4d8616c4295a34/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fde867a74e8c76c71e2f64f80c64c0f3163e687f1763cfaf21633ec24ec33", size = 3512103 },
+    { url = "https://files.pythonhosted.org/packages/96/19/139227a6e67f407b9c386cb594d9628c6c78c9024f26df87c912fabd4368/asyncpg-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46973045b567972128a27d40001124fbc821c87a6cade040cfcd4fa8a30bcdc4", size = 3592471 },
+    { url = "https://files.pythonhosted.org/packages/67/e4/ab3ca38f628f53f0fd28d3ff20edff1c975dd1cb22482e0061916b4b9a74/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9110df111cabc2ed81aad2f35394a00cadf4f2e0635603db6ebbd0fc896f46a4", size = 3496253 },
+    { url = "https://files.pythonhosted.org/packages/ef/5f/0bf65511d4eeac3a1f41c54034a492515a707c6edbc642174ae79034d3ba/asyncpg-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04ff0785ae7eed6cc138e73fc67b8e51d54ee7a3ce9b63666ce55a0bf095f7ba", size = 3662720 },
+    { url = "https://files.pythonhosted.org/packages/e7/31/1513d5a6412b98052c3ed9158d783b1e09d0910f51fbe0e05f56cc370bc4/asyncpg-0.30.0-cp313-cp313-win32.whl", hash = "sha256:ae374585f51c2b444510cdf3595b97ece4f233fde739aa14b50e0d64e8a7a590", size = 560404 },
+    { url = "https://files.pythonhosted.org/packages/c8/a4/cec76b3389c4c5ff66301cd100fe88c318563ec8a520e0b2e792b5b84972/asyncpg-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:f59b430b8e27557c3fb9869222559f7417ced18688375825f8f12302c34e915e", size = 621623 },
+]
+
 [[package]]
 name = "audioop-lts"
 version = "0.2.1"
@@ -224,9 +256,11 @@ version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
     { name = "anthropic" },
+    { name = "asyncpg" },
     { name = "elevenlabs" },
     { name = "gradio" },
-    { name = "psycopg2" },
+    { name = "greenlet" },
+    { name = "httpx" },
     { name = "python-dotenv" },
     { name = "requests" },
     { name = "sqlalchemy" },
@@ -247,9 +281,11 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "anthropic", specifier = ">=0.45.2" },
+    { name = "asyncpg", specifier = ">=0.28.0" },
     { name = "elevenlabs", specifier = ">=1.50.7" },
     { name = "gradio", specifier = ">=5.15.0" },
-    { name = "psycopg2", specifier = ">=2.9.0" },
+    { name = "greenlet", specifier = ">=2.0.0" },
+    { name = "httpx", specifier = ">=0.24.1" },
     { name = "python-dotenv", specifier = ">=1.0.1" },
     { name = "requests", specifier = ">=2.32.3" },
     { name = "sqlalchemy", specifier = ">=2.0.0" },
@@ -872,19 +908,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/43/b3/df14c580d82b9627d173ceea305ba898dca135feb360b6d84019d0803d3b/pre_commit-4.1.0-py2.py3-none-any.whl", hash = "sha256:d29e7cb346295bcc1cc75fc3e92e343495e3ea0196c9ec6ba53f49f10ab6ae7b", size = 220560 },
 ]
 
-[[package]]
-name = "psycopg2"
-version = "2.9.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/62/51/2007ea29e605957a17ac6357115d0c1a1b60c8c984951c19419b3474cdfd/psycopg2-2.9.10.tar.gz", hash = "sha256:12ec0b40b0273f95296233e8750441339298e6a572f7039da5b260e3c8b60e11", size = 385672 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/a2/c51ca3e667c34e7852157b665e3d49418e68182081060231d514dd823225/psycopg2-2.9.10-cp311-cp311-win32.whl", hash = "sha256:47c4f9875125344f4c2b870e41b6aad585901318068acd01de93f3677a6522c2", size = 1024538 },
-    { url = "https://files.pythonhosted.org/packages/33/39/5a9a229bb5414abeb86e33b8fc8143ab0aecce5a7f698a53e31367d30caa/psycopg2-2.9.10-cp311-cp311-win_amd64.whl", hash = "sha256:0435034157049f6846e95103bd8f5a668788dd913a7c30162ca9503fdf542cb4", size = 1163736 },
-    { url = "https://files.pythonhosted.org/packages/3d/16/4623fad6076448df21c1a870c93a9774ad8a7b4dd1660223b59082dd8fec/psycopg2-2.9.10-cp312-cp312-win32.whl", hash = "sha256:65a63d7ab0e067e2cdb3cf266de39663203d38d6a8ed97f5ca0cb315c73fe067", size = 1025113 },
-    { url = "https://files.pythonhosted.org/packages/66/de/baed128ae0fc07460d9399d82e631ea31a1f171c0c4ae18f9808ac6759e3/psycopg2-2.9.10-cp312-cp312-win_amd64.whl", hash = "sha256:4a579d6243da40a7b3182e0430493dbd55950c493d8c68f4eec0b302f6bbf20e", size = 1163951 },
-    { url = "https://files.pythonhosted.org/packages/ae/49/a6cfc94a9c483b1fa401fbcb23aca7892f60c7269c5ffa2ac408364f80dc/psycopg2-2.9.10-cp313-cp313-win_amd64.whl", hash = "sha256:91fd603a2155da8d0cfcdbf8ab24a2d54bca72795b90d2a3ed2b6da8d979dee2", size = 2569060 },
-]
-
 [[package]]
 name = "pydantic"
 version = "2.10.6"