s3 storage

Dockerfile

@@ -1,22 +1,25 @@
-# Hugging Face Spaces (Docker SDK) - FastAPI + Uvicorn + Redis + MongoDB
+# Hugging Face Spaces (Docker SDK) - FastAPI + Uvicorn + Redis + MongoDB + MinIO
 # Docs: https://huggingface.co/docs/hub/spaces-sdks-docker
 
 FROM python:3.12-slim
 
 # Install dependencies
-RUN apt-get update && apt-get install -y redis-server gnupg && \
+RUN apt-get update && apt-get install -y redis-server gnupg wget && \
     rm -rf /var/lib/apt/lists/*
 
-# Install MongoDB using the official approach with --allow-unauthenticated for build
+# Install MongoDB
 RUN apt-get update && \
     GNUPGHOME=/tmp gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 9B3B7D436F8E4A3426B64D3D610C8B9831C4F6FC && \
     GNUPGHOME=/tmp gpg --export 9B3B7D436F8E4A3426B64D3D610C8B9831C4F6FC > /usr/share/keyrings/mongodb-archive-keyring.gpg && \
     echo "deb [ signed-by=/usr/share/keyrings/mongodb-archive-keyring.gpg ] http://repo.mongodb.org/apt/debian bookworm/mongodb-org/7.0 main" | tee /etc/apt/sources.list.d/mongodb-org-7.0.list && \
     apt-get update && \
     apt-get install -y --allow-unauthenticated mongodb-org || \
-    (wget -qO- https://repo.mongodb.org/apt/debian/pool/mongodb-org-7.0-7.0.14/mongodb-org-server_7.0.14_amd64.deb -O /tmp/mongo.deb && dpkg -i /tmp/mongo.deb) || \
     echo "MongoDB install attempted"
 
+# Install MinIO
+RUN wget -q https://dl.min.io/server/minio/release/linux-amd64/minio -O /usr/local/bin/minio && \
+    chmod +x /usr/local/bin/minio
+
 # Create a non-root user matching HF Spaces expectations
 RUN useradd -m -u 1000 user
 USER user
@@ -31,6 +34,11 @@ ENV REDIS_DB="0"
 ENV CACHE_TTL="300"
 ENV MONGO_URI="mongodb://127.0.0.1:27017"
 ENV MONGO_DB_NAME="music_memories"
+ENV MINIO_ENDPOINT="127.0.0.1:9000"
+ENV MINIO_ACCESS_KEY="minioadmin"
+ENV MINIO_SECRET_KEY="minioadmin"
+ENV MINIO_BUCKET="music-memories"
+ENV MINIO_SECURE="false"
 WORKDIR /app
 
 # Install uv (dependency manager)
@@ -47,16 +55,18 @@ RUN uv venv /app/.venv \
 COPY --chown=user . /app
 
 # Ensure data directories exist and are writable
-RUN mkdir -p /app/chroma_db /app/data /app/redis_data /app/mongo_data && \
-    chown -R user:user /app/chroma_db /app/data /app/redis_data /app/mongo_data
+RUN mkdir -p /app/chroma_db /app/data /app/redis_data /app/mongo_data /app/minio_data && \
+    chown -R user:user /app/chroma_db /app/data /app/redis_data /app/mongo_data /app/minio_data
 
 # Seed the database (consistent data in every container)
 RUN uv run python seed_db.py
 
-EXPOSE 7860 6379 27017
+EXPOSE 7860 6379 27017 9000 9001
 
-# Start Redis, MongoDB and the app
+# Start Redis, MongoDB, MinIO and the app
 CMD ["sh", "-c", "\
     redis-server --daemonize yes --dir /app/redis_data --appendonly yes && \
     (mongod --dbpath /app/mongo_data --bind_ip 127.0.0.1 --fork --logpath /app/mongo_data/mongod.log 2>/dev/null || echo 'MongoDB not available') && \
+    (minio server /app/minio_data --address 127.0.0.1:9000 --console-address 127.0.0.1:9001 --quiet &>/dev/null &) && \
+    sleep 2 && \
     uvicorn main:app --host 0.0.0.0 --port 7860"]

database.py

@@ -31,7 +31,9 @@ def init_database() -> None:
                 album TEXT,
                 duration INTEGER,
                 bpm INTEGER,
-                energy_level INTEGER CHECK(energy_level BETWEEN 1 AND 10)
+                energy_level INTEGER CHECK(energy_level BETWEEN 1 AND 10),
+                audio_file_path TEXT,
+                file_size INTEGER
             )
         """)
         
@@ -134,6 +136,17 @@ def delete_song(song_id: int) -> bool:
         return cursor.rowcount > 0
 
 
+def update_song_file(song_id: int, audio_file_path: str, file_size: int) -> bool:
+    """Update song with MinIO file path and size."""
+    with get_db_connection() as conn:
+        cursor = conn.execute(
+            """UPDATE songs SET audio_file_path = ?, file_size = ? WHERE id = ?""",
+            (audio_file_path, file_size, song_id)
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
 # ============== USERS ==============
 
 def add_user(name: str) -> dict:

main.py

@@ -1,12 +1,12 @@
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, Query, HTTPException
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI, Query, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse, RedirectResponse, StreamingResponse
 import gradio as gr
 from app import gradio_app
 from database import (
     init_database,
     # Songs
-    add_song, get_all_songs, get_song_by_id, delete_song,
+    add_song, get_all_songs, get_song_by_id, delete_song, update_song_file,
     # Users
     add_user, get_all_users, get_user_by_id,
     # Playlists
@@ -58,17 +58,30 @@ from mongo_client import (
     log_search,
     get_popular_searches,
 )
+from minio_client import (
+    init_minio,
+    get_minio_client,
+    upload_mp3_file,
+    download_mp3_file,
+    stream_mp3_file,
+    delete_mp3_file,
+    get_file_metadata,
+    list_all_mp3_files,
+    check_minio_health,
+)
+import io
 
 app = FastAPI()
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Application lifespan manager for Redis, MongoDB and database initialization."""
+    """Application lifespan manager for Redis, MongoDB, MinIO and database initialization."""
     # Startup
     init_database()
     await init_redis()
     await init_mongodb()
+    init_minio()
     yield
     # Shutdown
     await close_redis()
@@ -85,11 +98,12 @@ def greet_json():
 
 @app.get("/health")
 async def health_check():
-    """Health check endpoint with Redis and MongoDB status."""
+    """Health check endpoint with Redis, MongoDB and MinIO status."""
     from redis_client import get_redis_client
     redis_status = "disconnected"
     mongo_status = "disconnected"
-    
+    minio_status = "disconnected"
+
     try:
         redis_client = get_redis_client()
         if redis_client:
@@ -97,7 +111,7 @@ async def health_check():
             redis_status = "connected"
     except Exception:
         redis_status = "error"
-    
+
     try:
         mongo_db = get_mongo_db()
         if mongo_db:
@@ -105,80 +119,222 @@ async def health_check():
             mongo_status = "connected"
     except Exception:
         mongo_status = "error"
-    
+
+    # MinIO health check
+    minio_health = check_minio_health()
+    minio_status = minio_health.get("status", "error")
+
     return {
         "status": "healthy",
         "redis": redis_status,
         "mongodb": mongo_status,
+        "minio": minio_status,
         "database": "sqlite"
     }
 
 
-# ============== SONGS ==============
+# ============== SONGS + MP3 FILES ==============
 
 @app.get("/songs")
 async def list_songs():
-    """Get all songs."""
+    """Get all songs with MinIO file info."""
     # Try cache first
     cached = await get_cached_list("all_songs")
     if cached:
         return {"songs": cached, "source": "cache"}
-    
+
     # Fetch from database
     songs = get_all_songs()
+    
+    # Add MinIO file info to each song
+    for song in songs:
+        file_meta = get_file_metadata(song["id"])
+        song["has_audio"] = file_meta is not None
+        song["file_size"] = file_meta.get("size") if file_meta else None
+
     await cache_list("all_songs", songs)
     return {"songs": songs, "source": "database"}
 
 
 @app.get("/songs/{song_id}")
 async def get_song(song_id: int):
-    """Get a song by ID with play count from MongoDB."""
+    """Get a song by ID with play count and MinIO file info."""
     # Try cache first
     song = await get_cached_song(song_id)
     if song:
-        # Add play count from MongoDB
         play_count = await get_song_play_count_mongo(song_id)
-        return {**song, "source": "cache", "play_count": play_count}
-    
+        file_meta = get_file_metadata(song_id)
+        return {
+            **song,
+            "source": "cache",
+            "play_count": play_count,
+            "has_audio": file_meta is not None,
+            "file_size": file_meta.get("size") if file_meta else None,
+        }
+
     # Fetch from database
     song = get_song_by_id(song_id)
     if not song:
         raise HTTPException(status_code=404, detail="Song not found")
-    
+
     # Add play count from MongoDB
     play_count = await get_song_play_count_mongo(song_id)
+    
+    # Add MinIO file info
+    file_meta = get_file_metadata(song_id)
+    
     await cache_song(song_id, song)
-    return {**song, "source": "database", "play_count": play_count}
+    return {
+        **song,
+        "source": "database",
+        "play_count": play_count,
+        "has_audio": file_meta is not None,
+        "file_size": file_meta.get("size") if file_meta else None,
+    }
 
 
 @app.post("/songs")
-async def create_song(title: str, artist: str, album: str = None, duration: int = None,
-                      bpm: int = None, energy_level: int = None, lyrics: str = None):
-    """Add a new song."""
+async def create_song(
+    title: str = Form(...),
+    artist: str = Form(...),
+    album: str = Form(None),
+    duration: int = Form(None),
+    bpm: int = Form(None),
+    energy_level: int = Form(None),
+    lyrics: str = Form(None),
+    audio_file: UploadFile = File(None),
+):
+    """Add a new song with optional MP3 file upload to MinIO."""
     song = add_song(title, artist, album, duration, bpm, energy_level)
+    
+    # Handle MP3 file upload to MinIO
+    minio_info = None
+    if audio_file and audio_file.filename:
+        contents = await audio_file.read()
+        file_stream = io.BytesIO(contents)
+        minio_info = upload_mp3_file(
+            file_data=file_stream,
+            file_size=len(contents),
+            song_id=song["id"],
+            filename=audio_file.filename,
+        )
+        
+        if minio_info:
+            # Update song with file reference
+            update_song_file(song["id"], minio_info["object_name"], minio_info["size"])
+    
     # Add to semantic search index if lyrics provided
     if lyrics:
         add_song_vibe(song["id"], title, artist, lyrics)
+    
     # Invalidate songs list cache
     await invalidate_list_cache("all_songs")
+    
     # Log activity to MongoDB
     await track_analytics_event("song_created", {"song_id": song["id"], "title": title})
-    return {"status": "success", "song": song}
+    
+    response = {"status": "success", "song": song}
+    if minio_info:
+        response["audio"] = {
+            "uploaded": True,
+            "size": minio_info["size"],
+            "stream_url": minio_info["presigned_url"],
+        }
+    return response
 
 
 @app.delete("/songs/{song_id}")
 async def delete_song_endpoint(song_id: int):
-    """Delete a song."""
+    """Delete a song and its MP3 file from MinIO."""
     if not delete_song(song_id):
         raise HTTPException(status_code=404, detail="Song not found")
+    
+    # Delete MP3 file from MinIO
+    delete_mp3_file(song_id)
+    
     remove_song_vibe(song_id)
     await invalidate_song_cache(song_id)
     await invalidate_list_cache("all_songs")
+    
     # Log activity to MongoDB
     await track_analytics_event("song_deleted", {"song_id": song_id})
     return {"status": "success", "deleted_id": song_id}
 
 
+# ============== MP3 FILE STREAMING ENDPOINTS ==============
+
+@app.get("/songs/{song_id}/stream")
+async def stream_song(song_id: int):
+    """Stream an MP3 file from MinIO (redirects to presigned URL)."""
+    stream_info = stream_mp3_file(song_id)
+    if not stream_info:
+        # Fallback: try to get from local storage
+        raise HTTPException(status_code=404, detail="Audio file not found")
+    
+    # Redirect to MinIO presigned URL for direct streaming
+    return RedirectResponse(url=stream_info["presigned_url"])
+
+
+@app.get("/songs/{song_id}/download")
+async def download_song(song_id: int):
+    """Download an MP3 file from MinIO."""
+    file_data = download_mp3_file(song_id)
+    if not file_data:
+        raise HTTPException(status_code=404, detail="Audio file not found")
+    
+    song = get_song_by_id(song_id)
+    filename = f"{song.get('title', 'song')}_{song_id}.mp3" if song else f"song_{song_id}.mp3"
+    
+    return StreamingResponse(
+        io.BytesIO(file_data),
+        media_type="audio/mpeg",
+        headers={"Content-Disposition": f"attachment; filename={filename}"},
+    )
+
+
+@app.post("/songs/{song_id}/upload-audio")
+async def upload_audio(song_id: int, audio_file: UploadFile = File(...)):
+    """Upload/update MP3 file for an existing song."""
+    # Verify song exists
+    song = get_song_by_id(song_id)
+    if not song:
+        raise HTTPException(status_code=404, detail="Song not found")
+    
+    # Validate file type
+    if not audio_file.filename.lower().endswith('.mp3'):
+        raise HTTPException(status_code=400, detail="Only MP3 files are supported")
+    
+    # Read and upload file
+    contents = await audio_file.read()
+    file_stream = io.BytesIO(contents)
+    
+    minio_info = upload_mp3_file(
+        file_data=file_stream,
+        file_size=len(contents),
+        song_id=song_id,
+        filename=audio_file.filename,
+    )
+    
+    if not minio_info:
+        raise HTTPException(status_code=500, detail="Failed to upload file to MinIO")
+    
+    # Update song with file reference
+    update_song_file(song_id, minio_info["object_name"], minio_info["size"])
+    
+    # Invalidate cache
+    await invalidate_song_cache(song_id)
+    await invalidate_list_cache("all_songs")
+    
+    return {
+        "status": "success",
+        "audio": {
+            "uploaded": True,
+            "size": minio_info["size"],
+            "stream_url": minio_info["presigned_url"],
+        },
+    }
+
+
 # ============== USERS ==============
 
 @app.get("/users")
@@ -188,7 +344,7 @@ async def list_users():
     cached = await get_cached_list("all_users")
     if cached:
         return {"users": cached, "source": "cache"}
-    
+
     # Fetch from database
     users = get_all_users()
     await cache_list("all_users", users)
@@ -202,12 +358,12 @@ async def get_user(user_id: int):
     user = await get_cached_user(user_id)
     if user:
         return {**user, "source": "cache"}
-    
+
     # Fetch from database
     user = get_user_by_id(user_id)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
-    
+
     await cache_user(user_id, user)
     return {**user, "source": "database"}
 
@@ -232,7 +388,7 @@ async def list_playlists():
     cached = await get_cached_list("all_playlists")
     if cached:
         return {"playlists": cached, "source": "cache"}
-    
+
     # Fetch from database
     playlists = get_all_playlists()
     await cache_list("all_playlists", playlists)
@@ -274,7 +430,7 @@ async def list_memories():
     cached = await get_cached_list("all_memories")
     if cached:
         return {"memories": cached, "source": "cache"}
-    
+
     # Fetch from database
     memories = get_all_memories()
     await cache_list("all_memories", memories)
@@ -286,12 +442,12 @@ async def list_user_memories(user_id: int):
     """Get memories for a specific user."""
     if not get_user_by_id(user_id):
         raise HTTPException(status_code=404, detail="User not found")
-    
+
     # Try cache first
     cached = await get_cached_list(f"user_memories:{user_id}")
     if cached:
         return {"memories": cached, "source": "cache"}
-    
+
     # Fetch from database
     memories = get_memories_by_user(user_id)
     await cache_list(f"user_memories:{user_id}", memories)
@@ -336,7 +492,7 @@ async def list_contexts():
     cached = await get_cached_list("all_contexts")
     if cached:
         return {"contexts": cached, "source": "cache"}
-    
+
     # Fetch from database
     contexts = get_all_contexts()
     await cache_list("all_contexts", contexts)
@@ -403,7 +559,7 @@ async def create_history(user_id: int, song_id: int, context_id: int = None, dur
     """Add a play history entry to MongoDB (primary), Redis (cache), and SQLite (backup)."""
     # Get song info for MongoDB storage
     song = get_song_by_id(song_id)
-    
+
     # Store in MongoDB (primary storage for analytics)
     mongo_result = await store_play_history_mongo(
         user_id=user_id,
@@ -413,20 +569,20 @@ async def create_history(user_id: int, song_id: int, context_id: int = None, dur
         context_id=context_id,
         duration_seconds=duration_seconds
     )
-    
+
     # Store in Redis (fast cache)
     await store_play_event(user_id, song_id, context_id)
-    
+
     # Store in SQLite (backup)
     sqlite_history = add_play_history(user_id, song_id, context_id)
-    
+
     # Log analytics event
     await track_analytics_event("song_played", {
         "user_id": user_id,
         "song_id": song_id,
         "context_id": context_id
     })
-    
+
     return {
         "status": "success",
         "history": sqlite_history,
@@ -465,6 +621,13 @@ async def get_user_activity(user_id: int, limit: int = Query(50), action_type: s
     return {"activity": activity}
 
 
+@app.get("/storage/files")
+async def list_storage_files():
+    """List all MP3 files in MinIO storage."""
+    files = list_all_mp3_files()
+    return {"files": files, "count": len(files)}
+
+
 # ============== SEMANTIC SEARCH ==============
 
 @app.get("/search/songs")

minio_client.py

@@ -0,0 +1,211 @@
+"""MinIO client module for S3-compatible object storage (MP3 files)."""
+
+import os
+import io
+from typing import Optional, BinaryIO, Dict, Any
+from datetime import timedelta
+from minio import Minio
+from minio.error import S3Error
+
+# MinIO configuration from environment variables
+MINIO_ENDPOINT = os.getenv("MINIO_ENDPOINT", "localhost:9000")
+MINIO_ACCESS_KEY = os.getenv("MINIO_ACCESS_KEY", "minioadmin")
+MINIO_SECRET_KEY = os.getenv("MINIO_SECRET_KEY", "minioadmin")
+MINIO_BUCKET = os.getenv("MINIO_BUCKET", "music-memories")
+MINIO_SECURE = os.getenv("MINIO_SECURE", "false").lower() == "true"
+
+# Global MinIO client instance
+_minio_client: Optional[Minio] = None
+
+
+def get_minio_client() -> Optional[Minio]:
+    """Get or create the MinIO client instance."""
+    global _minio_client
+    if _minio_client is None:
+        try:
+            _minio_client = Minio(
+                MINIO_ENDPOINT,
+                access_key=MINIO_ACCESS_KEY,
+                secret_key=MINIO_SECRET_KEY,
+                secure=MINIO_SECURE,
+            )
+        except Exception as e:
+            print(f"⚠ MinIO client creation failed: {e}")
+            return None
+    return _minio_client
+
+
+def init_minio() -> bool:
+    """Initialize MinIO bucket."""
+    client = get_minio_client()
+    if client is None:
+        print("⚠ MinIO not available")
+        return False
+    
+    try:
+        # Create bucket if it doesn't exist
+        if not client.bucket_exists(MINIO_BUCKET):
+            client.make_bucket(MINIO_BUCKET)
+            print(f"✓ Created MinIO bucket: {MINIO_BUCKET}")
+        else:
+            print(f"✓ MinIO bucket exists: {MINIO_BUCKET}")
+        return True
+    except S3Error as e:
+        print(f"⚠ MinIO bucket creation failed: {e}")
+        return False
+
+
+def upload_mp3_file(
+    file_data: BinaryIO,
+    file_size: int,
+    song_id: int,
+    filename: str = None
+) -> Optional[Dict[str, Any]]:
+    """Upload an MP3 file to MinIO."""
+    client = get_minio_client()
+    if client is None:
+        return None
+    
+    # Generate object name
+    object_name = f"songs/{song_id}/{filename or f'song_{song_id}.mp3'}"
+    
+    try:
+        # Upload the file
+        client.put_object(
+            MINIO_BUCKET,
+            object_name,
+            file_data,
+            length=file_size,
+            content_type="audio/mpeg",
+        )
+        
+        # Generate presigned URL for streaming (expires in 7 days)
+        presigned_url = client.presigned_get_object(
+            MINIO_BUCKET,
+            object_name,
+            expires=timedelta(days=7),
+        )
+        
+        return {
+            "object_name": object_name,
+            "bucket": MINIO_BUCKET,
+            "size": file_size,
+            "presigned_url": presigned_url,
+            "content_type": "audio/mpeg",
+        }
+    except S3Error as e:
+        print(f"⚠ MinIO upload failed: {e}")
+        return None
+
+
+def download_mp3_file(song_id: int, filename: str = None) -> Optional[bytes]:
+    """Download an MP3 file from MinIO."""
+    client = get_minio_client()
+    if client is None:
+        return None
+    
+    object_name = f"songs/{song_id}/{filename or f'song_{song_id}.mp3'}"
+    
+    try:
+        response = client.get_object(MINIO_BUCKET, object_name)
+        return response.read()
+    except S3Error as e:
+        print(f"⚠ MinIO download failed: {e}")
+        return None
+
+
+def stream_mp3_file(song_id: int, filename: str = None) -> Optional[Any]:
+    """Get a streaming response for an MP3 file."""
+    client = get_minio_client()
+    if client is None:
+        return None
+    
+    object_name = f"songs/{song_id}/{filename or f'song_{song_id}.mp3'}"
+    
+    try:
+        # Generate presigned URL for direct streaming
+        presigned_url = client.presigned_get_object(
+            MINIO_BUCKET,
+            object_name,
+            expires=timedelta(hours=24),
+        )
+        return {"presigned_url": presigned_url, "object_name": object_name}
+    except S3Error as e:
+        print(f"⚠ MinIO stream URL generation failed: {e}")
+        return None
+
+
+def delete_mp3_file(song_id: int, filename: str = None) -> bool:
+    """Delete an MP3 file from MinIO."""
+    client = get_minio_client()
+    if client is None:
+        return False
+    
+    object_name = f"songs/{song_id}/{filename or f'song_{song_id}.mp3'}"
+    
+    try:
+        client.remove_object(MINIO_BUCKET, object_name)
+        return True
+    except S3Error as e:
+        print(f"⚠ MinIO delete failed: {e}")
+        return False
+
+
+def get_file_metadata(song_id: int, filename: str = None) -> Optional[Dict[str, Any]]:
+    """Get metadata for an MP3 file."""
+    client = get_minio_client()
+    if client is None:
+        return None
+    
+    object_name = f"songs/{song_id}/{filename or f'song_{song_id}.mp3'}"
+    
+    try:
+        stat = client.stat_object(MINIO_BUCKET, object_name)
+        return {
+            "size": stat.size,
+            "content_type": stat.content_type,
+            "last_modified": stat.last_modified.isoformat() if stat.last_modified else None,
+            "etag": stat.etag,
+        }
+    except S3Error as e:
+        print(f"⚠ MinIO metadata fetch failed: {e}")
+        return None
+
+
+def list_all_mp3_files() -> list:
+    """List all MP3 files in the bucket."""
+    client = get_minio_client()
+    if client is None:
+        return []
+    
+    try:
+        objects = client.list_objects(MINIO_BUCKET, prefix="songs/", recursive=True)
+        return [
+            {
+                "object_name": obj.object_name,
+                "size": obj.size,
+                "last_modified": obj.last_modified.isoformat() if obj.last_modified else None,
+            }
+            for obj in objects
+        ]
+    except S3Error as e:
+        print(f"⚠ MinIO list failed: {e}")
+        return []
+
+
+def check_minio_health() -> Dict[str, Any]:
+    """Check MinIO health status."""
+    client = get_minio_client()
+    if client is None:
+        return {"status": "disconnected", "error": "Client not initialized"}
+    
+    try:
+        # Check if bucket exists (lightweight health check)
+        exists = client.bucket_exists(MINIO_BUCKET)
+        return {
+            "status": "connected" if exists else "bucket_missing",
+            "bucket": MINIO_BUCKET,
+            "endpoint": MINIO_ENDPOINT,
+        }
+    except S3Error as e:
+        return {"status": "error", "error": str(e)}

pyproject.toml

@@ -16,6 +16,8 @@ dependencies = [
    "redis>=5.0.0",
    "pymongo>=4.6.0",
    "motor>=3.4.0",
+   "minio>=7.2.0",
+   "python-multipart>=0.0.9",
    "sentence-transformers>=3.0.0",
    "torch>=2.5.0",
    "torchaudio>=2.5.0",