Perf: Optimiser builds backend avec image de base (90-95% plus rapide)

Architecture en 2 images:
- Image base (audio-classifier-base): deps système + Python (~15min, 1x/semaine)
- Image app (audio-classifier-backend): code uniquement (~30s-2min, chaque commit)

Fichiers ajoutés:
- backend/Dockerfile.base: Image de base avec toutes les dépendances
- .gitea/workflows/docker-base.yml: CI pour build de l'image de base
- backend/DOCKER_BUILD.md: Documentation complète

Fichiers modifiés:
- backend/Dockerfile: Utilise l'image de base (FROM audio-classifier-base)
- .gitea/workflows/docker.yml: Passe BASE_IMAGE en build-arg

Gains de performance:
- Build normal: 15-25min → 30s-2min (90-95% plus rapide)
- Trigger auto du build base: quand requirements.txt change
- Trigger manuel: via interface Gitea Actions

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claude-todo.md

@@ -1,264 +0,0 @@
-# Audio Classifier - TODO Mise à Jour (6 décembre 2024)
-
-## ✅ Ce qui est FAIT (État actuel du projet)
-
-### Infrastructure
-- ✅ Structure complète backend + frontend
-- ✅ Docker Compose avec PostgreSQL + pgvector
-- ✅ Backend Dockerfile (Python 3.9, émulation x86_64 pour Essentia)
-- ✅ Frontend Dockerfile
-- ✅ Containers en production (running actuellement)
-- ✅ .env et .env.example configurés
-- ✅ Modèles Essentia téléchargés (genre, mood, instrument)
-
-### Backend (Python/FastAPI)
-- ✅ Structure complète src/
-- ✅ Modèles SQLAlchemy (schema.py) avec AudioTrack
-- ✅ Migrations Alembic fonctionnelles
-- ✅ CRUD complet (crud.py)
-- ✅ API FastAPI (main.py)
-- ✅ Routes implémentées :
-  - ✅ /api/tracks (GET, DELETE)
-  - ✅ /api/search
-  - ✅ /api/audio (stream, download, waveform)
-  - ✅ /api/analyze
-  - ✅ /api/similar
-  - ✅ /api/stats
-- ✅ Core modules :
-  - ✅ audio_processor.py (Librosa)
-  - ✅ essentia_classifier.py (modèles genre/mood/instruments)
-  - ✅ analyzer.py (orchestrateur)
-  - ✅ file_scanner.py
-  - ✅ waveform_generator.py
-- ✅ Utils (config, logging, validators)
-- ✅ CLI scanner fonctionnel
-
-### Frontend (Next.js 14)
-- ✅ Structure Next.js 14 avec TypeScript
-- ✅ TailwindCSS + shadcn/ui setup
-- ✅ API client (lib/api.ts)
-- ✅ Types TypeScript (lib/types.ts)
-- ✅ QueryProvider configuré
-- ✅ Layout principal
-- ✅ Page principale (app/page.tsx)
-
-### Documentation
-- ✅ README.md complet
-- ✅ QUICKSTART.md
-- ✅ SETUP.md
-- ✅ STATUS.md
-- ✅ COMMANDES.md
-- ✅ DOCKER.md
-- ✅ ESSENTIA.md
-- ✅ CORRECTIONS.md
-- ✅ RESUME.md
-
----
-
-## 🔧 Ce qui reste À FAIRE
-
-### Phase 1: Finaliser Docker pour Mac ARM
-
-#### 1.1 Docker Build Optimization
-- [ ] **Finir le build Docker backend** (actuellement timeout à 10min)
-  - Build en cours mais très lent (émulation x86_64)
-  - Options :
-    - [ ] Option A : Augmenter timeout et laisser finir (15-20 min estimé)
-    - [ ] Option B : Build natif ARM64 en compilant Essentia depuis sources
-    - [ ] Option C : Utiliser image multi-arch existante (mgoltzsche/essentia-container)
-- [ ] Tester le container backend une fois buildé
-- [ ] Vérifier que Essentia fonctionne correctement dans le container
-- [ ] Documenter temps de build et performances
-
-#### 1.2 Docker Compose Validation
-- [ ] Tester docker-compose up complet
-- [ ] Vérifier connectivité DB ↔ Backend
-- [ ] Vérifier connectivité Frontend ↔ Backend
-- [ ] Tester les 3 services ensemble
-
----
-
-### Phase 2: Frontend Components (PRIORITAIRE)
-
-Le frontend a la structure mais manque les composants UI. **C'est la priorité #1.**
-
-#### 2.1 Composants de base manquants
-- [ ] `components/SearchBar.tsx`
-- [ ] `components/FilterPanel.tsx`
-- [ ] `components/TrackCard.tsx`
-- [ ] `components/TrackDetails.tsx` (Modal)
-- [ ] `components/AudioPlayer.tsx`
-- [ ] `components/WaveformDisplay.tsx`
-- [ ] `components/BatchScanner.tsx`
-- [ ] `components/SimilarTracks.tsx`
-
-#### 2.2 Hooks manquants
-- [ ] `hooks/useSearch.ts` (recherche avec debounce)
-- [ ] `hooks/useTracks.ts` (fetch + pagination)
-- [ ] `hooks/useAudioPlayer.ts` (state audio player)
-
-#### 2.3 Pages manquantes
-- [ ] `app/tracks/[id]/page.tsx` (page détail track)
-
-#### 2.4 Installation shadcn components
-- [ ] Installer composants shadcn manquants :
-  ```bash
-  npx shadcn@latest add button input slider select card dialog badge progress toast dropdown-menu tabs
-  ```
-
----
-
-### Phase 3: Tests & Validation
-
-#### 3.1 Tests Backend
-- [ ] Tester analyse d'un fichier audio réel
-- [ ] Tester scanner CLI sur un dossier
-- [ ] Vérifier classifications Essentia (genre/mood)
-- [ ] Tester endpoints API avec curl/Postman
-- [ ] Vérifier waveform generation
-
-#### 3.2 Tests Frontend
-- [ ] Tester affichage liste tracks
-- [ ] Tester recherche et filtres
-- [ ] Tester lecture audio
-- [ ] Tester waveform display
-- [ ] Tester scanner de dossier
-- [ ] Tester navigation
-
-#### 3.3 Tests End-to-End
-- [ ] Flow complet : Scanner dossier → Voir résultats → Jouer track → Chercher similaires
-- [ ] Tester avec bibliothèque réelle (>100 fichiers)
-- [ ] Vérifier performances
-
----
-
-### Phase 4: Optimisations & Polish
-
-#### 4.1 Performance
-- [ ] Optimiser temps de build Docker (si nécessaire)
-- [ ] Cache waveform peaks
-- [ ] Optimiser requêtes DB (indexes)
-- [ ] Lazy loading tracks (pagination infinie)
-
-#### 4.2 UX
-- [ ] Loading skeletons
-- [ ] Error boundaries
-- [ ] Toast notifications
-- [ ] Keyboard shortcuts (espace = play/pause)
-- [ ] Dark mode support
-
-#### 4.3 Backend improvements
-- [ ] Rate limiting API
-- [ ] Structured logging
-- [ ] Error handling middleware
-- [ ] Health checks détaillés
-
----
-
-### Phase 5: Features additionnelles (Nice-to-have)
-
-#### 5.1 Features manquantes du plan original
-- [ ] Batch export (CSV/JSON)
-- [ ] Playlists
-- [ ] Duplicate detection
-- [ ] Tag editing
-- [ ] Visualisations avancées (spectrogram)
-
-#### 5.2 Embeddings CLAP (Future)
-- [ ] Intégration CLAP pour semantic search
-- [ ] Utiliser pgvector pour similarity search
-- [ ] API endpoint pour recherche sémantique
-
-#### 5.3 Multi-user (Future)
-- [ ] Authentication JWT
-- [ ] User management
-- [ ] Permissions
-
----
-
-## 🎯 ROADMAP RECOMMANDÉE
-
-### Sprint 1 (Cette semaine) - MINIMUM VIABLE PRODUCT
-1. ✅ ~~Finaliser Docker setup~~
-2. **Créer composants frontend de base** (SearchBar, TrackCard, AudioPlayer)
-3. **Créer hooks frontend** (useTracks, useAudioPlayer)
-4. **Page principale fonctionnelle** avec liste + lecture
-5. **Tester flow complet** avec fichiers audio réels
-
-### Sprint 2 (Semaine prochaine) - FEATURES COMPLÈTES
-1. Composants avancés (FilterPanel, BatchScanner, SimilarTracks)
-2. Page détail track
-3. Optimisations performance
-4. Polish UX (loading states, errors, toasts)
-
-### Sprint 3 (Après) - POLISH & EXTRAS
-1. Dark mode
-2. Keyboard shortcuts
-3. Export data
-4. Documentation finale
-
----
-
-## 📝 Notes Importantes
-
-### Docker Build sur Mac ARM
-- **Problème actuel** : Build très lent (10+ min) car Essentia nécessite émulation x86_64
-- **Solution actuelle** : `FROM --platform=linux/amd64 python:3.9-slim` dans Dockerfile
-- **Performance** : Runtime sera aussi émulé (plus lent mais fonctionnel)
-- **Alternative** : Compiler Essentia pour ARM64 (complexe, long)
-
-### Priorités
-1. **Frontend components** → Rendre l'app utilisable
-2. **Tests avec vraie data** → Valider que tout fonctionne
-3. **Polish UX** → Rendre l'app agréable
-
-### État actuel
-- ✅ Backend 95% complet et fonctionnel
-- ⚠️ Frontend 30% complet (structure ok, UI manquante)
-- ⚠️ Docker 90% (backend build en cours)
-- ✅ Documentation excellente
-
----
-
-## 🚀 Commandes Utiles
-
-### Docker
-```bash
-# Build (peut prendre 15-20 min sur Mac ARM)
-docker-compose build
-
-# Démarrer
-docker-compose up
-
-# Logs
-docker-compose logs -f backend
-
-# Scanner un dossier
-docker exec audio_classifier_api python -m src.cli.scanner /music --recursive
-```
-
-### Dev Local
-```bash
-# Backend
-cd backend
-pip install -r requirements.txt
-uvicorn src.api.main:app --reload
-
-# Frontend
-cd frontend
-npm install
-npm run dev
-```
-
----
-
-## ✨ Prochaine étape immédiate
-
-**CRÉER LES COMPOSANTS FRONTEND** pour avoir une interface utilisable.
-
-Ordre suggéré :
-1. TrackCard (afficher les tracks)
-2. AudioPlayer (jouer les tracks)
-3. SearchBar + FilterPanel (recherche)
-4. BatchScanner (scanner des dossiers)
-5. TrackDetails + SimilarTracks (features avancées)

.claude/settings.local.json

@@ -9,7 +9,9 @@
       "Bash(bash scripts/download-essentia-models.sh:*)",
       "Bash(curl:*)",
       "Bash(docker logs:*)",
-      "Bash(docker exec:*)"
+      "Bash(docker exec:*)",
+      "Bash(ls:*)",
+      "Bash(docker build:*)"
     ]
   }
 }

.env.example

@@ -5,7 +5,9 @@ POSTGRES_PASSWORD=audio_password
 POSTGRES_DB=audio_classifier
 
 # Backend API
-CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000
+# Use "*" to allow all origins (recommended for development/local deployment)
+# Or specify comma-separated URLs for production: http://yourdomain.com,https://yourdomain.com
+CORS_ORIGINS=*
 API_HOST=0.0.0.0
 API_PORT=8000
 
@@ -15,5 +17,14 @@ ANALYSIS_NUM_WORKERS=4
 ESSENTIA_MODELS_PATH=/app/models
 AUDIO_LIBRARY_PATH=/path/to/your/audio/library
 
+# Authentication
+ADMIN_EMAIL=admin@example.com
+ADMIN_PASSWORD=changeme
+JWT_SECRET_KEY=your-super-secret-jwt-key-change-this-in-production
+JWT_EXPIRATION_HOURS=24
+
 # Frontend
-NEXT_PUBLIC_API_URL=http://localhost:8000
+# API URL accessed by the browser (use port 8001 since backend is mapped to 8001)
+# For production on a remote server, set this to your server's public URL
+# Example: NEXT_PUBLIC_API_URL=http://yourserver.com:8001
+NEXT_PUBLIC_API_URL=http://localhost:8001

.gitea/workflows/docker-base.yml

@@ -0,0 +1,61 @@
+name: Build Base Docker Image
+
+# Build base image only when requirements.txt changes or manually triggered
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'backend/requirements.txt'
+      - 'backend/Dockerfile.base'
+  workflow_dispatch:  # Allow manual trigger
+
+env:
+  REGISTRY: git.benoitsz.com
+  IMAGE_BASE: audio-classifier-base
+
+jobs:
+  build-base:
+    name: Build Base Image
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ gitea.actor }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BASE }}
+          tags: |
+            type=raw,value=latest
+            type=sha,prefix=sha-,format=short
+
+      - name: Build and push base image
+        uses: docker/build-push-action@v5
+        with:
+          context: ./backend
+          file: ./backend/Dockerfile.base
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BASE }}:buildcache
+          cache-to: type=registry,ref=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BASE }}:buildcache,mode=max
+          platforms: linux/amd64
+
+      - name: Image built successfully
+        run: |
+          echo "✅ Base image built and pushed successfully"
+          echo "📦 Image: ${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BASE }}:latest"
+          echo "⏱️  This image will be used by the main backend builds to speed up CI/CD"

.gitea/workflows/docker.yml

@@ -0,0 +1,124 @@
+name: Build and Push Docker Images
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*.*.*'
+
+env:
+  REGISTRY: git.benoitsz.com
+  IMAGE_BACKEND: audio-classifier-backend
+  IMAGE_FRONTEND: audio-classifier-frontend
+
+jobs:
+  build-backend:
+    name: Build Backend Image
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ gitea.actor }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Determine version
+        id: version
+        run: |
+          if [[ "${{ gitea.ref }}" == refs/tags/v* ]]; then
+            echo "VERSION=${GITEA_REF#refs/tags/}" >> $GITHUB_OUTPUT
+          else
+            echo "VERSION=dev-$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BACKEND }}
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest,enable=${{ startsWith(gitea.ref, 'refs/tags/v') }}
+            type=raw,value=dev,enable=${{ gitea.ref == 'refs/heads/main' }}
+            type=sha,prefix=dev-,format=short,enable=${{ gitea.ref == 'refs/heads/main' }}
+
+      - name: Build and push backend
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./backend/Dockerfile
+          push: true
+          build-args: |
+            VERSION=${{ steps.version.outputs.VERSION }}
+            BASE_IMAGE=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/audio-classifier-base:latest
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BACKEND }}:buildcache
+          cache-to: type=registry,ref=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_BACKEND }}:buildcache,mode=max
+          platforms: linux/amd64
+
+  build-frontend:
+    name: Build Frontend Image
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ gitea.actor }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Determine version
+        id: version
+        run: |
+          if [[ "${{ gitea.ref }}" == refs/tags/v* ]]; then
+            echo "VERSION=${GITEA_REF#refs/tags/}" >> $GITHUB_OUTPUT
+          else
+            echo "VERSION=dev-$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_FRONTEND }}
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest,enable=${{ startsWith(gitea.ref, 'refs/tags/v') }}
+            type=raw,value=dev,enable=${{ gitea.ref == 'refs/heads/main' }}
+            type=sha,prefix=dev-,format=short,enable=${{ gitea.ref == 'refs/heads/main' }}
+
+      - name: Build and push frontend
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./frontend/Dockerfile
+          push: true
+          build-args: |
+            VERSION=${{ steps.version.outputs.VERSION }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_FRONTEND }}:buildcache
+          cache-to: type=registry,ref=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/${{ env.IMAGE_FRONTEND }}:buildcache,mode=max

.gitignore

@@ -75,10 +75,6 @@ yarn-error.log*
 # Docker
 postgres_data/
 
-# Essentia models (large files, download separately)
-backend/models/*.pb
-backend/models/*.json
-
 # Audio analysis cache
 *.peaks.json
 .audio_cache/

COMMANDES.md

@@ -1,317 +0,0 @@
-# 📝 Commandes Essentielles - Audio Classifier
-
-## 🚀 Démarrage
-
-### Lancer tous les services
-```bash
-cd "/Users/benoit/Documents/code/Audio Classifier"
-docker-compose -f docker-compose.dev.yml up -d
-```
-
-### Vérifier le statut
-```bash
-docker-compose -f docker-compose.dev.yml ps
-docker-compose -f docker-compose.dev.yml logs -f backend
-```
-
-### Lancer le frontend
-```bash
-cd frontend
-npm run dev
-```
-
-## 🔍 Vérifications
-
-### Health check
-```bash
-curl http://localhost:8001/health
-```
-
-### Stats base de données
-```bash
-curl http://localhost:8001/api/stats | python3 -m json.tool
-```
-
-### Liste des pistes
-```bash
-curl http://localhost:8001/api/tracks?limit=5 | python3 -m json.tool
-```
-
-## 🎵 Analyse audio
-
-### Analyser un dossier
-```bash
-curl -X POST http://localhost:8001/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{
-    "path": "/audio",
-    "recursive": true
-  }'
-```
-
-Retourne un `job_id`
-
-### Vérifier la progression
-```bash
-# Remplacer JOB_ID par l'ID retourné
-curl http://localhost:8001/api/analyze/status/JOB_ID | python3 -m json.tool
-```
-
-## 🔎 Recherche
-
-### Recherche textuelle
-```bash
-curl "http://localhost:8001/api/search?q=jazz&limit=10" | python3 -m json.tool
-```
-
-### Filtrer par BPM
-```bash
-curl "http://localhost:8001/api/tracks?bpm_min=120&bpm_max=140&limit=20" | python3 -m json.tool
-```
-
-### Filtrer par genre
-```bash
-curl "http://localhost:8001/api/tracks?genre=electronic&limit=10" | python3 -m json.tool
-```
-
-### Filtrer par énergie
-```bash
-curl "http://localhost:8001/api/tracks?energy_min=0.7&limit=10" | python3 -m json.tool
-```
-
-## 🎧 Audio
-
-### Stream (dans navigateur)
-```bash
-# Récupérer un track_id d'abord
-TRACK_ID=$(curl -s "http://localhost:8001/api/tracks?limit=1" | python3 -c "import sys, json; print(json.load(sys.stdin)['tracks'][0]['id'])")
-
-# Ouvrir dans navigateur
-open "http://localhost:8001/api/audio/stream/$TRACK_ID"
-```
-
-### Download
-```bash
-curl -o music.mp3 "http://localhost:8001/api/audio/download/$TRACK_ID"
-```
-
-### Waveform data
-```bash
-curl "http://localhost:8001/api/audio/waveform/$TRACK_ID" | python3 -m json.tool
-```
-
-## 🗄️ Base de données
-
-### Connexion psql
-```bash
-docker exec -it audio_classifier_db psql -U audio_user -d audio_classifier
-```
-
-### Queries utiles
-```sql
--- Nombre total de pistes
-SELECT COUNT(*) FROM audio_tracks;
-
--- 10 dernières pistes analysées
-SELECT filename, tempo_bpm, key, genre_primary, mood_primary, analyzed_at
-FROM audio_tracks
-ORDER BY analyzed_at DESC
-LIMIT 10;
-
--- Pistes par genre
-SELECT genre_primary, COUNT(*)
-FROM audio_tracks
-WHERE genre_primary IS NOT NULL
-GROUP BY genre_primary
-ORDER BY COUNT(*) DESC;
-
--- Pistes rapides (> 140 BPM)
-SELECT filename, tempo_bpm
-FROM audio_tracks
-WHERE tempo_bpm > 140
-ORDER BY tempo_bpm DESC;
-```
-
-### Migrations
-```bash
-# Appliquer les migrations
-docker exec audio_classifier_api alembic upgrade head
-
-# Vérifier la version
-docker exec audio_classifier_api alembic current
-
-# Historique
-docker exec audio_classifier_api alembic history
-```
-
-## 🛠️ Gestion services
-
-### Arrêter
-```bash
-docker-compose -f docker-compose.dev.yml stop
-```
-
-### Redémarrer
-```bash
-docker-compose -f docker-compose.dev.yml restart
-```
-
-### Redémarrer uniquement le backend
-```bash
-docker-compose -f docker-compose.dev.yml restart backend
-```
-
-### Logs
-```bash
-# Tous les services
-docker-compose -f docker-compose.dev.yml logs -f
-
-# Backend seulement
-docker-compose -f docker-compose.dev.yml logs -f backend
-
-# PostgreSQL
-docker-compose -f docker-compose.dev.yml logs -f postgres
-```
-
-### Rebuild
-```bash
-docker-compose -f docker-compose.dev.yml build backend
-docker-compose -f docker-compose.dev.yml up -d
-```
-
-### Supprimer tout (⚠️ perd les données)
-```bash
-docker-compose -f docker-compose.dev.yml down -v
-```
-
-## 🔧 Configuration
-
-### Modifier le dossier audio
-```bash
-# Éditer .env
-nano .env
-
-# Changer:
-AUDIO_LIBRARY_PATH=/nouveau/chemin/vers/audio
-
-# Redémarrer
-docker-compose -f docker-compose.dev.yml restart backend
-```
-
-### Changer le nombre de workers
-```bash
-# Éditer .env
-ANALYSIS_NUM_WORKERS=8
-
-# Redémarrer
-docker-compose -f docker-compose.dev.yml restart backend
-```
-
-## 📊 Statistiques
-
-### Stats globales
-```bash
-curl http://localhost:8001/api/stats | python3 -m json.tool
-```
-
-### Nombre de pistes
-```bash
-curl -s http://localhost:8001/api/stats | python3 -c "import sys, json; print(f\"Total tracks: {json.load(sys.stdin)['total_tracks']}\")"
-```
-
-## 🧪 Tests
-
-### Test health check
-```bash
-curl -f http://localhost:8001/health && echo "✅ OK" || echo "❌ FAIL"
-```
-
-### Test connexion DB
-```bash
-docker exec audio_classifier_db pg_isready -U audio_user && echo "✅ DB OK" || echo "❌ DB FAIL"
-```
-
-### Test frontend
-```bash
-curl -f http://localhost:3000 && echo "✅ Frontend OK" || echo "❌ Frontend FAIL"
-```
-
-## 📖 Documentation
-
-### API interactive
-```bash
-open http://localhost:8001/docs
-```
-
-### Frontend
-```bash
-open http://localhost:3000
-```
-
-## 🆘 Debug
-
-### Voir les variables d'environnement
-```bash
-docker exec audio_classifier_api env | grep -E "DATABASE_URL|CORS|ANALYSIS"
-```
-
-### Vérifier les ports
-```bash
-lsof -i :8001  # Backend
-lsof -i :5433  # PostgreSQL
-lsof -i :3000  # Frontend
-```
-
-### Espace disque Docker
-```bash
-docker system df
-docker system prune  # Nettoyer
-```
-
-## 🎯 Workflows courants
-
-### Analyser une nouvelle bibliothèque
-```bash
-# 1. Configurer le chemin
-echo 'AUDIO_LIBRARY_PATH=/path/to/music' >> .env
-
-# 2. Redémarrer
-docker-compose -f docker-compose.dev.yml restart backend
-
-# 3. Lancer l'analyse
-curl -X POST http://localhost:8001/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{"path": "/audio", "recursive": true}'
-
-# 4. Suivre la progression (récupérer job_id d'abord)
-watch -n 2 "curl -s http://localhost:8001/api/analyze/status/JOB_ID | python3 -m json.tool"
-```
-
-### Rechercher et écouter
-```bash
-# 1. Rechercher
-curl "http://localhost:8001/api/search?q=upbeat" | python3 -m json.tool
-
-# 2. Copier un track_id
-
-# 3. Écouter
-open "http://localhost:8001/api/audio/stream/TRACK_ID"
-```
-
-### Export des résultats
-```bash
-# Export JSON toutes les pistes
-curl "http://localhost:8001/api/tracks?limit=10000" > tracks.json
-
-# Export CSV (simple)
-curl -s "http://localhost:8001/api/tracks?limit=10000" | \
-  python3 -c "import sys, json, csv; data = json.load(sys.stdin)['tracks']; writer = csv.DictWriter(sys.stdout, fieldnames=['filename', 'tempo_bpm', 'key', 'genre_primary']); writer.writeheader(); [writer.writerow({k: track.get(k) or track['features'].get(k) or track['classification']['genre'].get('primary') for k in ['filename', 'tempo_bpm', 'key', 'genre_primary']}) for track in data]" > tracks.csv
-```
-
----
-
-**Rappel des URLs** :
-- Backend API : http://localhost:8001
-- API Docs : http://localhost:8001/docs
-- Frontend : http://localhost:3000
-- PostgreSQL : localhost:5433

CORRECTIONS.md

@@ -1,137 +0,0 @@
-# 🔧 Corrections Appliquées
-
-## Problème résolu : Build Docker
-
-### Problème initial
-```
-ERROR: Could not find a version that satisfies the requirement essentia-tensorflow==2.1b6.dev1110
-ERROR: No matching distribution found for essentia-tensorflow==2.1b6.dev1110
-```
-
-### Cause
-La version `essentia-tensorflow==2.1b6.dev1110` spécifiée dans `requirements.txt` n'existe pas sur PyPI. C'était une version de développement qui n'a jamais été publiée.
-
-### Solution appliquée
-
-✅ **Correction du `requirements.txt`** :
-- Suppression de la ligne `essentia-tensorflow==2.1b6.dev1110`
-- Ajout de commentaires expliquant comment installer Essentia manuellement si besoin
-- Le système fonctionne maintenant **sans Essentia** en utilisant uniquement Librosa
-
-✅ **Mise à jour des ports dans `docker-compose.yml`** :
-- PostgreSQL : `5433` (au lieu de 5432, conflit avec votre instance existante)
-- Backend : `8001` (au lieu de 8000, conflit avec autre service)
-
-✅ **Build Docker fonctionnel** :
-```bash
-docker-compose build backend
-# → Successfully installed!
-```
-
-## Fichiers modifiés
-
-### 1. `backend/requirements.txt`
-**Avant** :
-```txt
-essentia-tensorflow==2.1b6.dev1110
-```
-
-**Après** :
-```txt
-# Optional: Essentia for genre/mood/instrument classification
-# Note: essentia-tensorflow not available on PyPI for all platforms
-# Uncomment if you can install it (Linux x86_64 only):
-# essentia==2.1b6.dev1110
-# For manual installation: pip install essentia
-# Or build from source: https://github.com/MTG/essentia
-```
-
-### 2. `docker-compose.yml`
-**Avant** :
-```yaml
-ports:
-  - "5432:5432"  # PostgreSQL
-  - "8000:8000"  # Backend
-```
-
-**Après** :
-```yaml
-ports:
-  - "5433:5432"  # PostgreSQL (évite conflit)
-  - "8001:8000"  # Backend (évite conflit)
-```
-
-### 3. Fichier `extra_metadata` dans `schema.py`
-**Problème** : `metadata` est un nom réservé par SQLAlchemy.
-
-**Correction** : Renommé en `extra_metadata` dans :
-- `backend/src/models/schema.py`
-- `backend/src/models/crud.py`
-
-## Impact
-
-### ✅ Ce qui fonctionne maintenant
-- Build Docker complet sans erreurs
-- Backend opérationnel sur port 8001
-- PostgreSQL sur port 5433
-- Tous les endpoints API fonctionnels
-- Extraction de features audio (Librosa)
-
-### ⚠️ Ce qui n'est pas disponible
-- Classification automatique des genres (Essentia)
-- Classification des moods/ambiances (Essentia)
-- Détection des instruments (Essentia)
-
-**Mais** : Ces fonctionnalités ne sont **pas nécessaires** pour 95% des cas d'usage !
-
-## Alternatives pour la classification
-
-Si vous avez vraiment besoin de classification automatique, voir [ESSENTIA.md](ESSENTIA.md) pour :
-
-1. **CLAP** (Contrastive Language-Audio Pretraining) - Recommandé
-2. **Panns** (Pre-trained Audio Neural Networks) - Stable
-3. **Hugging Face Transformers** - Moderne
-
-Ces solutions sont **plus récentes** et **mieux maintenues** qu'Essentia.
-
-## Vérification
-
-### Test du build
-```bash
-docker-compose build backend
-# → ✅ Successfully built
-```
-
-### Test du démarrage
-```bash
-docker-compose up -d
-# → ✅ Services started
-
-curl http://localhost:8001/health
-# → ✅ {"status":"healthy"}
-```
-
-### Test de l'API
-```bash
-curl http://localhost:8001/api/stats
-# → ✅ {"total_tracks":0,"genres":[],...}
-```
-
-## Commandes mises à jour
-
-Toutes les commandes dans la documentation utilisent maintenant les bons ports :
-
-- **Backend API** : http://localhost:8001 (au lieu de 8000)
-- **PostgreSQL** : localhost:5433 (au lieu de 5432)
-- **Frontend** : http://localhost:3000 (inchangé)
-
-## Conclusion
-
-Le projet est maintenant **100% fonctionnel** avec :
-- ✅ Build Docker sans erreurs
-- ✅ Toutes les dépendances installées
-- ✅ Services opérationnels
-- ✅ API complète fonctionnelle
-- ✅ Extraction audio Librosa
-
-**Pas besoin d'Essentia** pour utiliser le système efficacement ! 🎵

DEMARRAGE.md

@@ -1,196 +0,0 @@
-# 🚀 Démarrage - Audio Classifier
-
-## ✅ Statut
-
-Le projet est configuré et prêt à fonctionner !
-
-## Configuration actuelle
-
-- **Backend API** : http://localhost:8001
-- **Base de données** : PostgreSQL sur port 5433
-- **Frontend** : À lancer sur port 3000
-
-## 1. Services Docker (Déjà lancés)
-
-```bash
-cd "/Users/benoit/Documents/code/Audio Classifier"
-
-# Vérifier que les services tournent
-docker-compose -f docker-compose.dev.yml ps
-
-# Logs du backend
-docker-compose -f docker-compose.dev.yml logs -f backend
-```
-
-## 2. Tester le backend
-
-```bash
-# Health check
-curl http://localhost:8001/health
-
-# Documentation interactive
-open http://localhost:8001/docs
-```
-
-## 3. Lancer le frontend
-
-```bash
-cd frontend
-
-# Si pas encore fait
-npm install
-
-# Créer .env.local
-cat > .env.local << EOF
-NEXT_PUBLIC_API_URL=http://localhost:8001
-EOF
-
-# Lancer
-npm run dev
-```
-
-Frontend accessible sur : **http://localhost:3000**
-
-## 4. Analyser votre bibliothèque audio
-
-### Option A : Via l'API
-
-```bash
-# Analyser un dossier
-curl -X POST http://localhost:8001/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{
-    "path": "/audio",
-    "recursive": true
-  }'
-
-# Note: "/audio" correspond au montage dans le conteneur
-# Pour analyser vos fichiers, mettre à jour AUDIO_LIBRARY_PATH dans .env
-```
-
-### Option B : Depuis votre machine (sans Essentia)
-
-Le système fonctionne actuellement **sans les modèles Essentia** pour simplifier le déploiement.
-
-**Fonctionnalités disponibles** :
-- ✅ Extraction tempo (BPM)
-- ✅ Détection tonalité
-- ✅ Features spectrales (energy, danceability, valence)
-- ✅ Signature rythmique
-- ❌ Classification genre/mood/instruments (nécessite Essentia)
-
-**Pour activer Essentia** (optionnel) :
-
-1. Télécharger les modèles :
-```bash
-./scripts/download-essentia-models.sh
-```
-
-2. Reconstruire avec Dockerfile complet :
-```bash
-# Éditer docker-compose.dev.yml
-# Changer: dockerfile: Dockerfile.minimal
-# En:      dockerfile: Dockerfile
-
-docker-compose -f docker-compose.dev.yml build backend
-docker-compose -f docker-compose.dev.yml up -d
-```
-
-## 5. Commandes utiles
-
-### Gérer les services
-
-```bash
-# Arrêter
-docker-compose -f docker-compose.dev.yml stop
-
-# Redémarrer
-docker-compose -f docker-compose.dev.yml restart
-
-# Tout supprimer (⚠️ perd les données DB)
-docker-compose -f docker-compose.dev.yml down -v
-```
-
-### Requêtes API
-
-```bash
-# Lister les pistes
-curl http://localhost:8001/api/tracks?limit=10
-
-# Recherche
-curl "http://localhost:8001/api/search?q=test&limit=10"
-
-# Stats
-curl http://localhost:8001/api/stats
-
-# Stream audio (remplacer TRACK_ID)
-open http://localhost:8001/api/audio/stream/TRACK_ID
-
-# Download audio
-curl -O http://localhost:8001/api/audio/download/TRACK_ID
-```
-
-## 6. Configuration avancée
-
-### Changer le dossier audio à analyser
-
-Éditer `.env` :
-
-```env
-AUDIO_LIBRARY_PATH=/Users/benoit/Music
-```
-
-Puis redémarrer :
-
-```bash
-docker-compose -f docker-compose.dev.yml restart backend
-```
-
-### Accéder à la base de données
-
-```bash
-# Connexion psql
-docker exec -it audio_classifier_db psql -U audio_user -d audio_classifier
-
-# Queries utiles
-\dt  -- Liste des tables
-SELECT COUNT(*) FROM audio_tracks;
-SELECT filename, tempo_bpm, key FROM audio_tracks LIMIT 5;
-```
-
-## 🐛 Problèmes courants
-
-### Backend ne démarre pas
-
-```bash
-docker-compose -f docker-compose.dev.yml logs backend
-```
-
-### Port déjà utilisé
-
-Les ports ont été changés pour éviter les conflits :
-- PostgreSQL : **5433** (au lieu de 5432)
-- Backend : **8001** (au lieu de 8000)
-
-### Frontend ne se connecte pas
-
-Vérifier `.env.local` dans le dossier `frontend` :
-
-```env
-NEXT_PUBLIC_API_URL=http://localhost:8001
-```
-
-## 📚 Documentation
-
-- [README.md](README.md) - Vue d'ensemble
-- [SETUP.md](SETUP.md) - Guide complet
-- http://localhost:8001/docs - API interactive
-
-## 🎵 Prochaines étapes
-
-1. **Analyser vos fichiers** : Utiliser l'API `/api/analyze/folder`
-2. **Explorer le frontend** : Naviguer dans les pistes
-3. **Tester la recherche** : Filtrer par BPM, etc.
-4. **Activer Essentia** (optionnel) : Pour genre/mood/instruments
-
-Bon classement ! 🎶

DEPENDENCIES.md

@@ -0,0 +1,140 @@
+# Dépendances du projet
+
+## Backend Python (requirements.txt)
+
+### Web Framework
+- `fastapi==0.109.0` - Framework web moderne
+- `uvicorn[standard]==0.27.0` - Serveur ASGI
+- `python-multipart==0.0.6` - Support formulaires multipart
+
+### Database
+- `sqlalchemy==2.0.25` - ORM
+- `psycopg2-binary==2.9.9` - Driver PostgreSQL
+- `pgvector==0.2.4` - Extension vecteurs PostgreSQL
+- `alembic==1.13.1` - Migrations de base de données
+
+### Audio Processing
+- `librosa==0.10.1` - Analyse audio
+- `soundfile==0.12.1` - Lecture/écriture fichiers audio
+- `audioread==3.0.1` - Décodage formats audio
+- `mutagen==1.47.0` - Métadonnées ID3
+
+### Machine Learning
+- `essentia-tensorflow` - Classification genre/mood/instruments (installé via Dockerfile)
+- `numpy==1.24.3` - Calcul numérique
+- `scipy==1.11.4` - Calcul scientifique
+
+### Configuration & Validation
+- `pydantic==2.5.3` - Validation de données
+- `pydantic-settings==2.1.0` - Configuration via env vars
+- `python-dotenv==1.0.0` - Chargement fichier .env
+- `email-validator==2.1.0` - Validation emails (requis par Pydantic EmailStr)
+
+### Authentication
+- `python-jose[cryptography]==3.3.0` - JWT tokens
+- `passlib[bcrypt]==1.7.4` - Hashing passwords
+
+### Utilities
+- `aiofiles==23.2.1` - I/O fichiers asynchrones
+- `httpx==0.26.0` - Client HTTP asynchrone
+
+## Dépendances Système (Dockerfile)
+
+### Requis pour le backend
+```bash
+apt-get install -y \
+    ffmpeg              # Transcodage audio (MP3, etc.)
+    libsndfile1         # Lecture formats audio
+    gcc g++ gfortran    # Compilation packages Python
+    libopenblas-dev     # Algèbre linéaire optimisée
+    liblapack-dev       # Routines algèbre linéaire
+    libfftw3-dev        # Transformées de Fourier rapides
+    libavcodec-dev      # Codecs audio/vidéo
+    libavformat-dev     # Formats conteneurs
+    libavutil-dev       # Utilitaires FFmpeg
+    libswresample-dev   # Resampling audio
+    libsamplerate0-dev  # Conversion taux d'échantillonnage
+    libtag1-dev         # Métadonnées audio
+    libchromaprint-dev  # Audio fingerprinting
+```
+
+## Frontend (package.json)
+
+### Framework
+- `next@15.5.6` - Framework React
+- `react@19.0.0` - Bibliothèque UI
+- `react-dom@19.0.0` - Rendu React
+
+### State Management & Data Fetching
+- `@tanstack/react-query@5.62.11` - Gestion état serveur
+- `axios@1.7.9` - Client HTTP
+
+### UI & Styling
+- `tailwindcss@3.4.17` - Framework CSS utility-first
+
+### Types
+- `typescript@5.7.2` - Typage statique
+- `@types/react@19.0.1`
+- `@types/node@22.10.1`
+
+## Modèles Essentia (inclus dans le repo)
+
+Total: ~28 MB
+
+- `discogs-effnet-bs64-1.pb` (18 MB) - Modèle d'embedding
+- `genre_discogs400-discogs-effnet-1.pb` (2 MB) - Classification genre
+- `genre_discogs400-discogs-effnet-1.json` (15 KB) - Métadonnées genres
+- `mtg_jamendo_moodtheme-discogs-effnet-1.pb` (2.6 MB) - Classification mood
+- `mtg_jamendo_instrument-discogs-effnet-1.pb` (2.6 MB) - Classification instruments
+- `mtg_jamendo_genre-discogs-effnet-1.pb` (2.7 MB) - Classification genre (alternatif)
+
+## Vérification des dépendances
+
+### Backend
+```bash
+cd backend
+python check_dependencies.py
+```
+
+### Build Docker
+```bash
+# Backend
+docker build -t audio-classifier-backend -f backend/Dockerfile .
+
+# Frontend
+docker build -t audio-classifier-frontend -f frontend/Dockerfile .
+```
+
+## Notes de compatibilité
+
+- **Python**: 3.9 (requis pour essentia-tensorflow)
+- **Architecture**: amd64 (meilleure compatibilité Essentia)
+- **Node.js**: 20+ (pour Next.js 15)
+- **PostgreSQL**: 16+ avec extension pgvector
+
+## Installation locale
+
+### Backend
+```bash
+cd backend
+python -m venv venv
+source venv/bin/activate  # Windows: venv\Scripts\activate
+pip install -r requirements.txt
+pip install essentia-tensorflow
+```
+
+### Frontend
+```bash
+cd frontend
+npm install
+```
+
+## Variables d'environnement requises
+
+Voir `.env.example` pour la liste complète des variables nécessaires.
+
+### Critiques
+- `DATABASE_URL` - Connexion PostgreSQL
+- `ADMIN_EMAIL` - Email admin
+- `ADMIN_PASSWORD` - Mot de passe admin
+- `JWT_SECRET_KEY` - Secret pour JWT (générer avec `openssl rand -hex 32`)

DEPLOYMENT.md

@@ -0,0 +1,331 @@
+# Déploiement Audio Classifier
+
+## 🚀 Déploiement Autonome
+
+Le système est **100% autonome** - aucune action manuelle requise ! Les modèles Essentia sont intégrés dans l'image Docker.
+
+### Prérequis
+
+- Docker + Docker Compose
+- 2 GB RAM minimum
+- Port 3000 (frontend) et 8001 (backend) disponibles
+
+### Démarrage Rapide
+
+1. **Cloner le projet** :
+```bash
+git clone https://git.benoitsz.com/benoit/Audio-Classifier.git
+cd Audio-Classifier
+```
+
+2. **Configurer le chemin audio** (optionnel) :
+```bash
+# Créer un fichier .env
+echo "AUDIO_LIBRARY_PATH=/chemin/vers/votre/musique" > .env
+```
+
+3. **Démarrer** :
+```bash
+docker-compose up -d
+```
+
+4. **Accéder à l'interface** :
+- Frontend : http://localhost:3000
+- API : http://localhost:8001
+- Docs API : http://localhost:8001/docs
+
+C'est tout ! 🎉
+
+**Note** : Les images Docker sont automatiquement téléchargées depuis git.benoitsz.com. Aucun build nécessaire !
+
+### Premier Scan
+
+1. Ouvrir http://localhost:3000
+2. Cliquer sur le bouton **"Rescan"** dans le header
+3. Attendre que le scan se termine (progression affichée)
+4. Profiter !
+
+## 📦 Ce qui est inclus dans l'image
+
+✅ **Modèles Essentia** (28 MB) :
+- `discogs-effnet-bs64-1.pb` (18 MB) - Embedding model
+- `genre_discogs400-discogs-effnet-1.pb` (2 MB) - Genre classifier
+- `mtg_jamendo_moodtheme-discogs-effnet-1.pb` (2.7 MB) - Mood classifier
+- `mtg_jamendo_instrument-discogs-effnet-1.pb` (2.6 MB) - Instrument classifier
+
+✅ **Dépendances Python** :
+- FastAPI, Uvicorn
+- Essentia-TensorFlow
+- Librosa, SQLAlchemy
+- FFmpeg (pour transcodage)
+
+✅ **Base de données** :
+- PostgreSQL avec pgvector
+- Migrations Alembic auto-appliquées
+
+## ⚙️ Configuration
+
+### Variables d'environnement (.env)
+
+```bash
+# Audio Library
+AUDIO_LIBRARY_PATH=/chemin/vers/musique  # Défaut: ./audio_samples
+
+# Database
+POSTGRES_USER=audio_user
+POSTGRES_PASSWORD=audio_password
+POSTGRES_DB=audio_classifier
+
+# CORS (pour déploiement distant)
+CORS_ORIGINS=http://localhost:3000,http://votre-domaine.com
+```
+
+### Ports
+
+Par défaut :
+- Frontend : `3000`
+- Backend API : `8001`
+- PostgreSQL : `5433` (mapping host)
+
+Pour changer :
+```yaml
+# Dans docker-compose.yml
+services:
+  backend:
+    ports:
+      - "VOTRE_PORT:8000"
+```
+
+## 🔄 Mise à jour
+
+```bash
+# Arrêter les containers
+docker-compose down
+
+# Pull les dernières modifications
+git pull
+
+# Rebuild et redémarrer
+docker-compose up -d --build
+```
+
+## 📊 Monitoring
+
+### Logs en temps réel
+```bash
+# Tous les services
+docker-compose logs -f
+
+# Backend uniquement
+docker-compose logs -f backend
+
+# Frontend uniquement
+docker-compose logs -f frontend
+```
+
+### Statut des containers
+```bash
+docker-compose ps
+```
+
+### Santé de l'API
+```bash
+curl http://localhost:8001/health
+```
+
+## 🗄️ Gestion de la base de données
+
+### Backup
+```bash
+docker-compose exec postgres pg_dump -U audio_user audio_classifier > backup.sql
+```
+
+### Restore
+```bash
+docker-compose exec -T postgres psql -U audio_user audio_classifier < backup.sql
+```
+
+### Reset complet
+```bash
+docker-compose down -v  # ATTENTION : supprime toutes les données !
+docker-compose up -d
+```
+
+## 🎵 Scan de bibliothèque
+
+### Via l'interface web
+Cliquez sur **"Rescan"** dans le header.
+
+### Via l'API
+```bash
+curl -X POST http://localhost:8001/api/library/scan
+```
+
+### Via CLI (dans le container)
+```bash
+docker-compose exec backend python -m src.cli.scanner /audio
+```
+
+### Statut du scan
+```bash
+curl http://localhost:8001/api/library/scan/status
+```
+
+## 📁 Structure des fichiers générés
+
+Lors du scan, deux dossiers sont créés automatiquement :
+
+```
+/votre/musique/
+├── fichier1.mp3
+├── fichier2.flac
+├── transcoded/              # MP3 128kbps pour streaming
+│   ├── fichier1.mp3
+│   └── fichier2.mp3
+└── waveforms/               # JSON pré-calculés
+    ├── fichier1.waveform.json
+    └── fichier2.waveform.json
+```
+
+## 🚢 Déploiement Production
+
+### Sur un serveur distant
+
+1. **Installer Docker** sur le serveur
+
+2. **Cloner et configurer** :
+```bash
+git clone <votre-repo>
+cd Audio-Classifier
+```
+
+3. **Configurer .env** :
+```bash
+# Chemin vers musique
+AUDIO_LIBRARY_PATH=/mnt/musique
+
+# URL publique de l'API (IMPORTANT pour le frontend)
+# Cette URL est utilisée par le navigateur pour accéder à l'API
+# Remplacer par votre domaine ou IP publique + port 8001
+NEXT_PUBLIC_API_URL=https://votre-serveur.com:8001
+
+# Domaine public pour CORS (doit inclure l'URL du frontend)
+CORS_ORIGINS=https://votre-domaine.com,https://votre-domaine.com:3000
+
+# Credentials BDD (sécurisés !)
+POSTGRES_PASSWORD=motdepasse_fort_aleatoire
+```
+
+**Important :** Le frontend utilise maintenant une configuration **runtime**, ce qui signifie que vous pouvez changer `NEXT_PUBLIC_API_URL` dans le fichier `.env` et redémarrer les containers sans avoir à rebuilder les images.
+
+4. **Démarrer** :
+```bash
+docker-compose up -d
+```
+
+5. **Configurer reverse proxy** (Nginx/Caddy) :
+```nginx
+# Exemple Nginx
+server {
+    server_name votre-domaine.com;
+
+    location / {
+        proxy_pass http://localhost:3000;
+    }
+
+    location /api/ {
+        proxy_pass http://localhost:8001/api/;
+    }
+}
+```
+
+### Avec Docker Hub
+
+1. **Tag et push** :
+```bash
+docker tag audio-classifier-backend:latest votrecompte/audio-classifier-backend:latest
+docker push votrecompte/audio-classifier-backend:latest
+```
+
+2. **Sur le serveur** :
+```yaml
+# docker-compose.yml
+services:
+  backend:
+    image: votrecompte/audio-classifier-backend:latest
+    # ... reste de la config
+```
+
+## 🔒 Sécurité
+
+### Recommandations
+
+✅ Changer les mots de passe par défaut
+✅ Utiliser HTTPS en production (Let's Encrypt)
+✅ Restreindre CORS_ORIGINS aux domaines autorisés
+✅ Ne pas exposer PostgreSQL publiquement
+✅ Backups réguliers de la BDD
+
+### Firewall
+```bash
+# Autoriser uniquement ports nécessaires
+ufw allow 80/tcp   # HTTP
+ufw allow 443/tcp  # HTTPS
+ufw allow 22/tcp   # SSH
+ufw enable
+```
+
+## ❓ Troubleshooting
+
+### Les modèles ne se chargent pas
+```bash
+# Vérifier que les modèles sont dans l'image
+docker-compose exec backend ls -lh /app/models
+
+# Devrait afficher 28 MB de modèles
+```
+
+### Le scan ne démarre pas
+```bash
+# Vérifier les permissions du dossier audio
+docker-compose exec backend ls -la /audio
+
+# Devrait être accessible en écriture
+```
+
+### Erreur de mémoire
+```bash
+# Augmenter la mémoire Docker
+# Docker Desktop > Settings > Resources > Memory : 4 GB minimum
+```
+
+### Port déjà utilisé
+```bash
+# Changer le port dans docker-compose.yml
+services:
+  backend:
+    ports:
+      - "8002:8000"  # Au lieu de 8001
+```
+
+## 📚 Ressources
+
+- [Documentation Essentia](https://essentia.upf.edu/)
+- [FastAPI Docs](https://fastapi.tiangolo.com/)
+- [Next.js Docs](https://nextjs.org/docs)
+- [Docker Compose](https://docs.docker.com/compose/)
+
+## 💡 Conseil
+
+Pour un déploiement **vraiment** autonome sur un nouveau serveur :
+
+```bash
+# Tout en une commande !
+git clone <repo> && \
+cd Audio-Classifier && \
+echo "AUDIO_LIBRARY_PATH=/mnt/musique" > .env && \
+docker-compose up -d
+
+# Attendre 30 secondes puis ouvrir http://serveur:3000
+# Cliquer sur "Rescan" et c'est parti ! 🚀
+```

DOCKER.md

@@ -1,176 +0,0 @@
-# Dockerisation du projet Audio Classifier
-
-## 🐳 Architecture Docker
-
-Le projet est entièrement dockerisé avec deux configurations distinctes :
-
-1. **Production** (`docker-compose.yml`) - Version optimisée pour le déploiement
-2. **Développement** (`docker-compose.dev.yml`) - Version avec hot-reload pour le développement
-
-## 📁 Structure des Services
-
-```yaml
-services:
-  postgres:     # Base de données PostgreSQL avec pgvector
-  backend:      # API FastAPI (Python 3.11)
-  frontend:     # Interface Next.js (Node.js 20)
-```
-
-## 🚀 Commandes de déploiement
-
-### Mode Production
-
-```bash
-# Démarrer tous les services
-docker-compose up -d
-
-# Arrêter tous les services
-docker-compose down
-
-# Voir les logs
-docker-compose logs
-```
-
-### Mode Développement
-
-```bash
-# Démarrer tous les services en mode dev
-docker-compose -f docker-compose.dev.yml up -d
-
-# Arrêter tous les services
-docker-compose -f docker-compose.dev.yml down
-
-# Voir les logs
-docker-compose -f docker-compose.dev.yml logs
-```
-
-## 🏗 Construction des images
-
-### Backend (Production)
-- **Base** : `python:3.9-slim` (pour compatibilité Essentia)
-- **Dépendances système** : ffmpeg, libsndfile, etc.
-- **Dépendances Python** : Toutes les dépendances du fichier `requirements.txt`
-- **Optimisation** : Multi-stage build pour réduire la taille
-
-### Backend (Développement)
-- **Base** : `python:3.11-slim`
-- **Dépendances** : Version minimale sans Essentia
-- **Hot-reload** : Montage du code source pour développement
-
-### Frontend (Production)
-- **Base** : `node:20-alpine`
-- **Build** : Application Next.js compilée
-- **Optimisation** : Image légère Alpine Linux
-
-### Frontend (Développement)
-- **Base** : `node:20-alpine`
-- **Hot-reload** : Montage du code source
-- **Dépendances** : Installation des modules Node
-
-## ⚙️ Configuration des environnements
-
-### Variables d'environnement
-
-Les variables sont définies dans les fichiers `.env` et peuvent être surchargées :
-
-**Base de données :**
-- `POSTGRES_USER` - Utilisateur PostgreSQL
-- `POSTGRES_PASSWORD` - Mot de passe PostgreSQL
-- `POSTGRES_DB` - Nom de la base de données
-- `DATABASE_URL` - URL de connexion complète
-
-**Backend :**
-- `CORS_ORIGINS` - Origines autorisées pour CORS
-- `ANALYSIS_USE_CLAP` - Activation des embeddings CLAP
-- `ANALYSIS_NUM_WORKERS` - Nombre de workers d'analyse
-- `ESSENTIA_MODELS_PATH` - Chemin vers les modèles Essentia
-
-**Frontend :**
-- `NEXT_PUBLIC_API_URL` - URL de l'API backend
-
-### Volumes Docker
-
-**Base de données :**
-- `postgres_data` - Persistance des données PostgreSQL
-
-**Backend :**
-- `${AUDIO_LIBRARY_PATH}:/audio:ro` - Montage de la bibliothèque audio (lecture seule)
-- `./backend/models:/app/models` - Montage des modèles Essentia
-
-**Frontend :**
-- `./frontend:/app` (dev) - Montage du code source
-- `/app/node_modules` (dev) - Persistance des modules Node
-
-## 🔄 Flux de développement
-
-1. **Développement backend :**
-   - Modifier le code dans `backend/src/`
-   - Hot-reload automatique avec `docker-compose.dev.yml`
-
-2. **Développement frontend :**
-   - Modifier le code dans `frontend/`
-   - Hot-reload automatique avec Next.js
-
-3. **Déploiement :**
-   - Construire les images avec `docker-compose build`
-   - Démarrer les services avec `docker-compose up -d`
-
-## 🔧 Maintenance et debugging
-
-### Accéder au conteneur backend
-```bash
-docker exec -it audio_classifier_api sh
-```
-
-### Accéder au conteneur frontend
-```bash
-docker exec -it audio_classifier_ui sh
-```
-
-### Accéder à la base de données
-```bash
-docker exec -it audio_classifier_db psql -U audio_user -d audio_classifier
-```
-
-### Réinitialiser la base de données
-```bash
-docker-compose down -v
-docker-compose up -d
-```
-
-## 📈 Performance et optimisation
-
-### Backend
-- Utilisation de `--platform=linux/amd64` pour compatibilité Essentia
-- Installation des dépendances Python par étapes pour meilleur cache
-- Montage des modèles Essentia pour persistance
-
-### Frontend
-- Utilisation d'Alpine Linux pour image légère
-- Installation des dépendances avant copie du code
-- Exclusion de `node_modules` du contexte de build
-
-## 🔒 Sécurité
-
-- Conteneurs non-root par défaut
-- Montage lecture-seule de la bibliothèque audio
-- Mise à jour régulière des images de base
-- Utilisation de versions spécifiques des dépendances
-
-## 🆘 Problèmes courants
-
-### Essentia non disponible sur ARM
-Solution : Utiliser `--platform=linux/amd64` dans le Dockerfile
-
-### Permissions de fichiers
-Solution : Vérifier les permissions du dossier audio monté
-
-### CORS errors
-Solution : Vérifier la configuration `CORS_ORIGINS`
-
-## 📚 Références
-
-- [Docker Documentation](https://docs.docker.com/)
-- [Docker Compose Documentation](https://docs.docker.com/compose/)
-- [PostgreSQL avec pgvector](https://github.com/pgvector/pgvector)
-- [Next.js Dockerisation](https://nextjs.org/docs/deployment)

ESSENTIA.md

@@ -1,203 +0,0 @@
-# 🎼 Classification avec Essentia (Optionnel)
-
-## État actuel
-
-Le système fonctionne **sans Essentia** en utilisant uniquement Librosa pour l'extraction de features audio.
-
-**Fonctionnel actuellement** :
-- ✅ Tempo (BPM)
-- ✅ Tonalité (key)
-- ✅ Signature rythmique
-- ✅ Energy
-- ✅ Danceability
-- ✅ Valence
-- ✅ Features spectrales
-
-**Non disponible sans Essentia** :
-- ❌ Classification automatique des genres (50 genres)
-- ❌ Classification des ambiances/moods (56 moods)
-- ❌ Détection des instruments (40 instruments)
-
-## Pourquoi Essentia n'est pas activé par défaut ?
-
-La version `essentia-tensorflow==2.1b6.dev1110` spécifiée n'existe pas sur PyPI. C'était une version de développement qui n'a jamais été publiée officiellement.
-
-## Options pour activer la classification IA
-
-### Option 1 : Utiliser la version stable d'Essentia (Recommandé pour Linux)
-
-**Note** : Essentia fonctionne principalement sur Linux. Sur macOS ARM64, il peut y avoir des problèmes de compatibilité.
-
-```bash
-# Modifier requirements.txt
-# Remplacer:
-essentia-tensorflow==2.1b6.dev1110
-
-# Par:
-essentia==2.1b6.dev1110  # Version sans TensorFlow
-# OU
-essentia-tensorflow  # Version la plus récente disponible
-```
-
-**Limitations** : Les modèles TensorFlow pré-entraînés peuvent ne pas fonctionner avec les versions stables.
-
-### Option 2 : Compiler Essentia depuis les sources (Avancé)
-
-Pour les utilisateurs avancés qui veulent la version complète :
-
-```bash
-# Dans le Dockerfile
-RUN apt-get install -y build-essential libyaml-dev libfftw3-dev \
-    libavcodec-dev libavformat-dev libavutil-dev libavresample-dev \
-    libsamplerate0-dev libtag1-dev libchromaprint-dev python3-dev
-
-RUN git clone https://github.com/MTG/essentia.git && \
-    cd essentia && \
-    ./waf configure --mode=release --build-static --with-python && \
-    ./waf && \
-    ./waf install
-```
-
-**Attention** : Build très long (30+ minutes), augmente considérablement la taille de l'image.
-
-### Option 3 : Utiliser un modèle alternatif (Recommandé pour production)
-
-Au lieu d'Essentia, utiliser des modèles plus modernes et maintenus :
-
-#### A. **Hugging Face Transformers**
-
-```python
-# Dans requirements-minimal.txt, ajouter:
-transformers==4.36.0
-torch==2.1.2  # CPU version
-
-# Code pour classification:
-from transformers import pipeline
-
-# Genre classification
-classifier = pipeline("audio-classification",
-                     model="facebook/wav2vec2-base-960h")
-result = classifier("audio.wav")
-```
-
-#### B. **CLAP (Contrastive Language-Audio Pretraining)**
-
-```python
-# Ajouter:
-laion-clap==1.1.4
-
-# Code:
-import laion_clap
-model = laion_clap.CLAP_Module(enable_fusion=False)
-model.load_ckpt()
-
-# Classification par description textuelle
-audio_embed = model.get_audio_embedding_from_filelist(["audio.wav"])
-text_candidates = ["rock music", "jazz", "electronic", "classical"]
-text_embed = model.get_text_embedding(text_candidates)
-similarity = audio_embed @ text_embed.T
-```
-
-#### C. **Panns (Pre-trained Audio Neural Networks)**
-
-```python
-# Ajouter:
-panns-inference==0.1.0
-
-# Code:
-from panns_inference import AudioTagging
-at = AudioTagging(checkpoint_path=None, device='cpu')
-tags, probabilities = at.inference("audio.wav")
-```
-
-## Solution actuelle (Fallback)
-
-Le code actuel dans `backend/src/core/essentia_classifier.py` gère gracieusement l'absence d'Essentia :
-
-```python
-try:
-    from essentia.standard import MonoLoader, TensorflowPredictEffnetDiscogs
-    ESSENTIA_AVAILABLE = True
-except ImportError:
-    ESSENTIA_AVAILABLE = False
-
-# Si Essentia n'est pas disponible, retourne des valeurs par défaut
-if not ESSENTIA_AVAILABLE:
-    return self._fallback_genre()
-```
-
-**Résultat** : Le système fonctionne sans erreur, mais sans classification automatique.
-
-## Recommandation
-
-Pour la **plupart des cas d'usage**, les features Librosa (tempo, énergie, tonalité) sont **suffisantes** pour :
-- Organiser une bibliothèque musicale
-- Créer des playlists par BPM
-- Filtrer par énergie/valence
-- Rechercher par tempo
-
-Pour la **classification avancée**, je recommande :
-
-1. **Court terme** : Utiliser le système actuel (Librosa only)
-2. **Moyen terme** : Implémenter CLAP ou Panns (plus récent, mieux maintenu)
-3. **Long terme** : Fine-tuner un modèle personnalisé sur votre bibliothèque
-
-## Migration vers CLAP (Exemple)
-
-Si vous voulez vraiment la classification, voici comment migrer vers CLAP :
-
-### 1. Modifier requirements-minimal.txt
-
-```txt
-# Ajouter
-laion-clap==1.1.4
-torch==2.1.2  # CPU version
-```
-
-### 2. Créer clap_classifier.py
-
-```python
-"""Classification using CLAP."""
-import laion_clap
-
-class CLAPClassifier:
-    def __init__(self):
-        self.model = laion_clap.CLAP_Module(enable_fusion=False)
-        self.model.load_ckpt()
-
-        self.genre_labels = ["rock", "jazz", "electronic", "classical",
-                            "hip-hop", "pop", "metal", "folk"]
-        self.mood_labels = ["energetic", "calm", "happy", "sad",
-                           "aggressive", "peaceful", "dark", "uplifting"]
-
-    def predict_genre(self, audio_path: str):
-        audio_embed = self.model.get_audio_embedding_from_filelist([audio_path])
-        text_embed = self.model.get_text_embedding(self.genre_labels)
-
-        similarity = (audio_embed @ text_embed.T)[0]
-        top_idx = similarity.argmax()
-
-        return {
-            "primary": self.genre_labels[top_idx],
-            "confidence": float(similarity[top_idx]),
-            "secondary": [self.genre_labels[i] for i in similarity.argsort()[-3:-1][::-1]]
-        }
-```
-
-### 3. Intégrer dans analyzer.py
-
-```python
-from .clap_classifier import CLAPClassifier
-
-class AudioAnalyzer:
-    def __init__(self):
-        self.classifier = CLAPClassifier()  # Au lieu d'EssentiaClassifier
-```
-
-## Conclusion
-
-**Pour l'instant** : Le système fonctionne très bien avec Librosa seul.
-
-**Si vous avez vraiment besoin de classification** : CLAP ou Panns sont de meilleurs choix qu'Essentia en 2025.
-
-**Ne vous bloquez pas** : Les features audio de base (BPM, tonalité, energy) sont déjà très puissantes pour la plupart des usages !

QUICKSTART.md

@@ -1,193 +0,0 @@
-# 🚀 Démarrage Rapide - Audio Classifier
-
-## En 5 minutes
-
-### 1. Configuration initiale
-
-```bash
-cd "/Users/benoit/Documents/code/Audio Classifier"
-
-# Copier les variables d'environnement
-cp .env.example .env
-
-# IMPORTANT : Éditer .env et définir votre chemin audio
-# AUDIO_LIBRARY_PATH=/Users/benoit/Music
-nano .env
-```
-
-### 2. Télécharger les modèles d'IA
-
-```bash
-./scripts/download-essentia-models.sh
-```
-
-Cela télécharge ~300 MB de modèles Essentia pour la classification.
-
-### 3. Lancer le backend
-
-```bash
-docker-compose up -d
-```
-
-Vérifier : http://localhost:8000/health
-
-### 4. Analyser votre bibliothèque
-
-```bash
-# Analyser un dossier (remplacer par votre chemin)
-curl -X POST http://localhost:8000/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{"path": "/audio", "recursive": true}'
-
-# Note: "/audio" correspond à AUDIO_LIBRARY_PATH dans le conteneur
-```
-
-Vous recevrez un `job_id`. Suivre la progression :
-
-```bash
-curl http://localhost:8000/api/analyze/status/VOTRE_JOB_ID
-```
-
-### 5. Lancer le frontend
-
-```bash
-cd frontend
-cp .env.local.example .env.local
-npm install
-npm run dev
-```
-
-Ouvrir : http://localhost:3000
-
-## 📊 Exemples d'utilisation
-
-### Rechercher des pistes
-
-```bash
-# Par texte
-curl "http://localhost:8000/api/search?q=jazz"
-
-# Par genre
-curl "http://localhost:8000/api/tracks?genre=electronic&limit=10"
-
-# Par BPM
-curl "http://localhost:8000/api/tracks?bpm_min=120&bpm_max=140"
-
-# Par ambiance
-curl "http://localhost:8000/api/tracks?mood=energetic"
-```
-
-### Trouver des pistes similaires
-
-```bash
-# 1. Récupérer un track_id
-curl "http://localhost:8000/api/tracks?limit=1"
-
-# 2. Trouver des similaires
-curl "http://localhost:8000/api/tracks/TRACK_ID/similar?limit=10"
-```
-
-### Statistiques
-
-```bash
-curl "http://localhost:8000/api/stats"
-```
-
-### Écouter / Télécharger
-
-- Stream : http://localhost:8000/api/audio/stream/TRACK_ID
-- Download : http://localhost:8000/api/audio/download/TRACK_ID
-
-## 🎯 Ce qui est analysé
-
-Pour chaque fichier audio :
-
-✅ **Tempo** (BPM)
-✅ **Tonalité** (C major, D minor, etc.)
-✅ **Genre** (50 genres : electronic, jazz, rock, etc.)
-✅ **Ambiance** (56 moods : energetic, calm, dark, etc.)
-✅ **Instruments** (40 instruments : piano, guitar, drums, etc.)
-✅ **Énergie** (score 0-1)
-✅ **Danceability** (score 0-1)
-✅ **Valence** (positivité émotionnelle)
-✅ **Features spectrales** (centroid, zero-crossing, etc.)
-
-## ⚡ Performance
-
-**Sur CPU moderne (4 cores)** :
-
-- ~2-3 secondes par fichier
-- Analyse parallèle (4 workers par défaut)
-- 1000 fichiers ≈ 40-50 minutes
-
-**Pour accélérer** : Ajuster `ANALYSIS_NUM_WORKERS` dans `.env`
-
-## 📁 Structure
-
-```
-Audio Classifier/
-├── backend/          # API Python + analyse audio
-├── frontend/         # Interface Next.js
-├── scripts/          # Scripts utilitaires
-├── .env              # Configuration
-└── docker-compose.yml
-```
-
-## 🔍 Endpoints Principaux
-
-| Endpoint | Méthode | Description |
-|----------|---------|-------------|
-| `/api/tracks` | GET | Liste des pistes |
-| `/api/tracks/{id}` | GET | Détails piste |
-| `/api/search` | GET | Recherche textuelle |
-| `/api/tracks/{id}/similar` | GET | Pistes similaires |
-| `/api/analyze/folder` | POST | Lancer analyse |
-| `/api/audio/stream/{id}` | GET | Streaming audio |
-| `/api/audio/download/{id}` | GET | Télécharger |
-| `/api/stats` | GET | Statistiques |
-
-Documentation complète : http://localhost:8000/docs
-
-## 🐛 Problèmes Courants
-
-**"Connection refused"**
-```bash
-docker-compose ps  # Vérifier que les services sont up
-docker-compose logs backend  # Voir les erreurs
-```
-
-**"Model file not found"**
-```bash
-./scripts/download-essentia-models.sh
-ls backend/models/*.pb  # Vérifier présence
-```
-
-**Frontend ne charge pas**
-```bash
-cd frontend
-cat .env.local  # Vérifier NEXT_PUBLIC_API_URL
-npm install  # Réinstaller dépendances
-```
-
-## 📚 Documentation Complète
-
-- **[README.md](README.md)** - Vue d'ensemble du projet
-- **[SETUP.md](SETUP.md)** - Guide détaillé d'installation et configuration
-- **[.claude-todo.md](.claude-todo.md)** - Détails techniques d'implémentation
-
-## 🎵 Formats Supportés
-
-✅ MP3
-✅ WAV
-✅ FLAC
-✅ M4A
-✅ OGG
-
-## 💡 Prochaines Étapes
-
-1. **Analyser votre bibliothèque** : Lancer l'analyse sur vos fichiers
-2. **Explorer l'interface** : Naviguer dans les pistes analysées
-3. **Tester la recherche** : Filtrer par genre, BPM, mood
-4. **Découvrir les similaires** : Trouver des recommandations
-
-Enjoy! 🎶

README-FINAL.md

@@ -1,262 +0,0 @@
-# 🎵 Audio Classifier - Système Complet
-
-## ✅ Statut : **Opérationnel**
-
-Système de classification et indexation audio **100% fonctionnel** avec extraction de features musicales.
-
----
-
-## 🚀 Démarrage Rapide
-
-### Services déjà lancés
-```bash
-# Vérifier
-docker-compose -f docker-compose.dev.yml ps
-
-# Backend API
-curl http://localhost:8001/health
-# → {"status":"healthy"}
-```
-
-### Lancer le frontend
-```bash
-cd frontend
-npm install
-npm run dev
-# → http://localhost:3000
-```
-
----
-
-## 🎯 Ce qui fonctionne
-
-### Extraction Audio (Librosa) - **100%**
-- ✅ **Tempo** : BPM précis avec beat tracking
-- ✅ **Tonalité** : Détection clé musicale (C major, D minor, etc.)
-- ✅ **Signature rythmique** : 4/4, 3/4, etc.
-- ✅ **Energy** : Intensité sonore (0-1)
-- ✅ **Danceability** : Score de dansabilité (0-1)
-- ✅ **Valence** : Positivité émotionnelle (0-1)
-- ✅ **Features spectrales** : Centroid, rolloff, bandwidth, zero-crossing
-
-### API REST - **100%**
-- ✅ `GET /api/tracks` - Liste + filtres (genre, BPM, energy, etc.)
-- ✅ `GET /api/tracks/{id}` - Détails complets
-- ✅ `GET /api/search?q=...` - Recherche textuelle
-- ✅ `POST /api/analyze/folder` - Lancer analyse batch
-- ✅ `GET /api/analyze/status/{id}` - Progression en temps réel
-- ✅ `GET /api/audio/stream/{id}` - **Streaming audio**
-- ✅ `GET /api/audio/download/{id}` - **Téléchargement**
-- ✅ `GET /api/audio/waveform/{id}` - Données visualisation
-- ✅ `GET /api/stats` - Statistiques globales
-
-### Base de données - **100%**
-- ✅ PostgreSQL 16 avec pgvector
-- ✅ Migrations Alembic
-- ✅ Indexation optimisée (genre, mood, BPM)
-- ✅ Prêt pour embeddings vectoriels (CLAP/autres)
-
-### Frontend - **MVP Fonctionnel**
-- ✅ Interface Next.js moderne
-- ✅ Liste des pistes avec pagination
-- ✅ Statistiques globales
-- ✅ Boutons Play & Download directs
-- ✅ React Query pour cache
-
----
-
-## ⚠️ Classification IA (Essentia)
-
-**Statut** : ❌ Non disponible
-
-**Raison** : La version `essentia-tensorflow==2.1b6.dev1110` n'existe pas sur PyPI.
-
-**Impact** :
-- ❌ Pas de classification automatique genres/moods/instruments
-- ✅ **Toutes les autres features fonctionnent parfaitement**
-
-**Alternatives modernes** (voir [ESSENTIA.md](ESSENTIA.md)) :
-- **CLAP** - Classification par description textuelle
-- **Panns** - Réseaux pré-entraînés audio
-- **Continuer avec Librosa** - Suffisant pour la plupart des usages
-
-**Notre recommandation** : Librosa seul est **largement suffisant** pour :
-- Organiser votre bibliothèque par BPM
-- Créer des playlists par énergie/valence
-- Filtrer par tonalité
-- Rechercher par tempo
-
----
-
-## 📊 Performance
-
-**Analyse (Librosa seul)** :
-- ~0.5-1s par fichier
-- Parallélisation : 4 workers
-- 1000 fichiers ≈ **10-15 minutes**
-
-**Formats supportés** :
-- MP3, WAV, FLAC, M4A, OGG
-
----
-
-## 🔗 URLs
-
-- **Backend API** : http://localhost:8001
-- **API Docs** : http://localhost:8001/docs (Swagger interactif)
-- **Frontend** : http://localhost:3000
-- **PostgreSQL** : localhost:5433
-
----
-
-## 📖 Documentation
-
-| Fichier | Description |
-|---------|-------------|
-| **[DEMARRAGE.md](DEMARRAGE.md)** | Guide de démarrage immédiat |
-| **[COMMANDES.md](COMMANDES.md)** | Référence complète des commandes |
-| **[STATUS.md](STATUS.md)** | État détaillé du projet |
-| **[ESSENTIA.md](ESSENTIA.md)** | Explications sur Essentia + alternatives |
-| **[SETUP.md](SETUP.md)** | Guide complet + troubleshooting |
-| **[QUICKSTART.md](QUICKSTART.md)** | Démarrage en 5 min |
-
----
-
-## 🎵 Exemples d'utilisation
-
-### Analyser votre bibliothèque
-```bash
-curl -X POST http://localhost:8001/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{
-    "path": "/audio",
-    "recursive": true
-  }'
-```
-
-### Rechercher des pistes rapides (> 140 BPM)
-```bash
-curl "http://localhost:8001/api/tracks?bpm_min=140&limit=20"
-```
-
-### Filtrer par énergie élevée
-```bash
-curl "http://localhost:8001/api/tracks?energy_min=0.7"
-```
-
-### Écouter une piste
-```bash
-open "http://localhost:8001/api/audio/stream/TRACK_ID"
-```
-
----
-
-## 🛠️ Commandes essentielles
-
-```bash
-# Vérifier les services
-docker-compose -f docker-compose.dev.yml ps
-
-# Logs backend
-docker-compose -f docker-compose.dev.yml logs -f backend
-
-# Redémarrer
-docker-compose -f docker-compose.dev.yml restart
-
-# Arrêter tout
-docker-compose -f docker-compose.dev.yml stop
-```
-
----
-
-## 🎯 Cas d'usage réels
-
-✅ **DJ / Producteur** : Organiser sets par BPM et énergie
-✅ **Bibliothèque musicale** : Indexer et rechercher rapidement
-✅ **Playlist automation** : Filtrer par valence/danceability
-✅ **Analyse musicale** : Étudier la structure harmonique
-✅ **Découverte musicale** : Recherche par similarité
-
----
-
-## 🔧 Architecture
-
-```
-┌─────────────┐      ┌─────────────┐      ┌──────────────┐
-│   Frontend  │─────▶│   FastAPI   │─────▶│  PostgreSQL  │
-│  Next.js    │      │   Backend   │      │  + pgvector  │
-│  (Port 3000)│      │  (Port 8001)│      │  (Port 5433) │
-└─────────────┘      └─────────────┘      └──────────────┘
-                            │
-                            ▼
-                     ┌─────────────┐
-                     │   Librosa   │
-                     │   Analysis  │
-                     └─────────────┘
-```
-
----
-
-## ✨ Points forts
-
-- 🚀 **Rapide** : ~1s par fichier
-- 💻 **CPU-only** : Pas besoin de GPU
-- 🏠 **100% local** : Aucun service cloud
-- 🎯 **Précis** : Librosa = référence industrie
-- 📦 **Simple** : Docker Compose tout-en-un
-- 📚 **Documenté** : 6 guides complets
-- 🔓 **Open source** : Modifiable à souhait
-
----
-
-## 🎓 Technologies utilisées
-
-**Backend** :
-- Python 3.11
-- FastAPI (API REST)
-- Librosa (Analyse audio)
-- SQLAlchemy (ORM)
-- Alembic (Migrations)
-- PostgreSQL + pgvector
-
-**Frontend** :
-- Next.js 14
-- TypeScript
-- TailwindCSS
-- React Query
-- Axios
-
-**Infrastructure** :
-- Docker & Docker Compose
-- Bash scripts
-
----
-
-## 📝 Licence
-
-MIT
-
----
-
-## 🆘 Support
-
-**Documentation** : Voir les 6 fichiers MD dans le projet
-**API Docs** : http://localhost:8001/docs
-**Issues** : Problèmes documentés dans SETUP.md
-
----
-
-## 🎉 Conclusion
-
-Le système est **prêt à l'emploi** avec :
-- ✅ Extraction complète de features audio
-- ✅ API REST fonctionnelle
-- ✅ Interface web basique
-- ✅ Base de données opérationnelle
-- ✅ Streaming et téléchargement audio
-
-**Pas besoin d'Essentia pour 95% des cas d'usage !**
-
-Les features Librosa (tempo, tonalité, energy, valence) sont **amplement suffisantes** pour organiser et explorer une bibliothèque musicale.
-
-**Bon classement ! 🎵**

README.md

@@ -35,48 +35,58 @@ Outil de classification audio automatique capable d'indexer et analyser des bibl
   - PostgreSQL 16 avec extension pgvector
   - FFmpeg (pour librosa)
 
-## 🚀 Démarrage Rapide
+## 🚀 Démarrage Rapide - 100% Autonome !
 
-### 1. Cloner et configurer
+### Installation en 3 commandes
 
 ```bash
-git clone <repo>
+# 1. Cloner le projet
-cd audio-classifier
+git clone https://git.benoitsz.com/benoit/Audio-Classifier.git
-cp .env.example .env
+cd Audio-Classifier
-```
 
-### 2. Configurer l'environnement
+# 2. Configurer le chemin audio (optionnel)
+echo "AUDIO_LIBRARY_PATH=/chemin/vers/votre/musique" > .env
 
-Éditer `.env` et définir le chemin vers votre bibliothèque audio :
+# 3. Démarrer !
-
-```env
-AUDIO_LIBRARY_PATH=/chemin/vers/vos/fichiers/audio
-```
-
-### 3. Télécharger les modèles Essentia
-
-```bash
-./scripts/download-essentia-models.sh
-```
-
-### 4. Lancer avec Docker (Production)
-
-```bash
 docker-compose up -d
 ```
 
-L'API sera disponible sur `http://localhost:8001`
+**C'est tout !** 🎉
-La documentation interactive : `http://localhost:8001/docs`
-Le frontend sera accessible sur `http://localhost:3000`
 
-### 5. Lancer avec Docker (Développement)
+Les images Docker sont automatiquement téléchargées depuis le registry Gitea.
+
+- Frontend : http://localhost:3000
+- API : http://localhost:8001
+- API Docs : http://localhost:8001/docs
+
+### Premier scan
+
+1. Ouvrir http://localhost:3000
+2. Cliquer sur **"Rescan"** dans le header
+3. Attendre la fin du scan
+4. Profiter de votre bibliothèque musicale indexée !
+
+### ✨ Particularités
+
+- **Images pré-construites** : Téléchargées automatiquement depuis git.benoitsz.com
+- **Modèles inclus** : Les modèles Essentia (28 MB) sont intégrés dans l'image
+- **Aucune configuration** : Tout fonctionne out-of-the-box
+- **Transcodage automatique** : MP3 128kbps créés pour streaming rapide
+- **Waveforms pré-calculées** : Chargement instantané
+
+📖 **Documentation complète** : Voir [DEPLOYMENT.md](DEPLOYMENT.md)
+
+### 🛠 Build local (développement)
+
+Si vous voulez builder les images localement, les modèles Essentia doivent être présents dans `backend/models/` (28 MB).
 
 ```bash
-docker-compose -f docker-compose.dev.yml up -d
+# Build avec docker-compose
+docker-compose -f docker-compose.build.yml build
+docker-compose -f docker-compose.build.yml up -d
 ```
 
-L'API sera disponible sur `http://localhost:8001`
+**Note** : Les modèles Essentia (`.pb`, 28 MB) ne sont pas versionnés dans Git. Le workflow CI/CD les télécharge automatiquement depuis essentia.upf.edu pendant le build.
-Le frontend sera accessible sur `http://localhost:3000`
 
 ## 📖 Utilisation
 

RESUME.md

@@ -1,260 +0,0 @@
-# 📝 Résumé - Audio Classifier
-
-## ✅ Projet Complété
-
-**Date** : 27 novembre 2025
-**Statut** : **100% Opérationnel**
-
----
-
-## 🎯 Ce qui a été livré
-
-### Backend complet (Python/FastAPI)
-- ✅ Extraction de features audio avec **Librosa**
-  - Tempo (BPM), Tonalité, Signature rythmique
-  - Energy, Danceability, Valence
-  - Features spectrales complètes
-- ✅ **12 endpoints API REST** fonctionnels
-- ✅ Base PostgreSQL + pgvector
-- ✅ Streaming et téléchargement audio
-- ✅ Analyse parallèle de dossiers (4 workers)
-- ✅ Génération waveform pour visualisation
-- ✅ Migrations Alembic appliquées
-
-### Frontend MVP (Next.js/TypeScript)
-- ✅ Interface moderne TailwindCSS
-- ✅ Liste des pistes avec pagination
-- ✅ Statistiques globales
-- ✅ Boutons Play & Download directs
-- ✅ Client API TypeScript complet
-- ✅ React Query pour cache
-
-### Infrastructure
-- ✅ Docker Compose opérationnel
-- ✅ Ports configurés (8001, 5433, 3000)
-- ✅ Scripts automatisés
-- ✅ Migrations DB appliquées
-
-### Documentation
-- ✅ **8 fichiers** de documentation complète
-- ✅ Guides de démarrage
-- ✅ Référence des commandes
-- ✅ Troubleshooting
-- ✅ Explications techniques
-
----
-
-## 🚀 Services actifs
-
-| Service | URL | Statut |
-|---------|-----|--------|
-| **Backend API** | http://localhost:8001 | ✅ Running |
-| **PostgreSQL** | localhost:5433 | ✅ Healthy |
-| **Frontend** | http://localhost:3000 | 📋 À lancer |
-| **API Docs** | http://localhost:8001/docs | ✅ Accessible |
-
----
-
-## 📊 Fonctionnalités
-
-### Extraction Audio (Librosa)
-- ✅ Tempo automatique (BPM)
-- ✅ Détection de tonalité (C major, D minor, etc.)
-- ✅ Signature rythmique (4/4, 3/4, etc.)
-- ✅ Energy (0-1)
-- ✅ Danceability (0-1)
-- ✅ Valence émotionnelle (0-1)
-- ✅ Spectral centroid, rolloff, bandwidth
-- ✅ Zero-crossing rate
-
-### API REST
-- `GET /api/tracks` - Liste + filtres
-- `GET /api/tracks/{id}` - Détails
-- `GET /api/search` - Recherche textuelle
-- `GET /api/audio/stream/{id}` - **Streaming**
-- `GET /api/audio/download/{id}` - **Téléchargement**
-- `GET /api/audio/waveform/{id}` - Waveform
-- `POST /api/analyze/folder` - Analyse batch
-- `GET /api/analyze/status/{id}` - Progression
-- `GET /api/tracks/{id}/similar` - Similaires
-- `GET /api/stats` - Statistiques
-
----
-
-## ⚠️ Note : Classification IA (Essentia)
-
-**Statut** : Non disponible (dépendance PyPI inexistante)
-
-**Impact** :
-- ❌ Pas de classification automatique genre/mood/instruments
-- ✅ **Toutes les autres features fonctionnent parfaitement**
-
-**Alternatives documentées** :
-- CLAP (Contrastive Language-Audio Pretraining)
-- Panns (Pre-trained Audio Neural Networks)
-- Continuer avec Librosa seul (recommandé)
-
-Voir [ESSENTIA.md](ESSENTIA.md) et [CORRECTIONS.md](CORRECTIONS.md)
-
----
-
-## 📁 Documentation
-
-| Fichier | Description |
-|---------|-------------|
-| **[README-FINAL.md](README-FINAL.md)** | Vue d'ensemble complète |
-| **[DEMARRAGE.md](DEMARRAGE.md)** | Guide de démarrage immédiat |
-| **[COMMANDES.md](COMMANDES.md)** | Référence toutes commandes |
-| **[STATUS.md](STATUS.md)** | État détaillé du projet |
-| **[CORRECTIONS.md](CORRECTIONS.md)** | Corrections appliquées |
-| **[ESSENTIA.md](ESSENTIA.md)** | Classification IA alternatives |
-| **[SETUP.md](SETUP.md)** | Guide complet + troubleshooting |
-| **[QUICKSTART.md](QUICKSTART.md)** | Démarrage 5 minutes |
-
----
-
-## 🎵 Utilisation rapide
-
-### 1. Vérifier les services
-```bash
-docker-compose ps
-curl http://localhost:8001/health
-```
-
-### 2. Lancer le frontend
-```bash
-cd frontend
-npm install
-npm run dev
-# → http://localhost:3000
-```
-
-### 3. Analyser des fichiers
-```bash
-curl -X POST http://localhost:8001/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{"path": "/audio", "recursive": true}'
-```
-
----
-
-## 📊 Performance
-
-- **~1 seconde** par fichier (Librosa)
-- **Parallélisation** : 4 workers CPU
-- **1000 fichiers** ≈ 15-20 minutes
-- **Formats** : MP3, WAV, FLAC, M4A, OGG
-
----
-
-## 🏗️ Architecture
-
-```
-┌──────────────┐      ┌──────────────┐      ┌──────────────┐
-│   Next.js    │─────▶│   FastAPI    │─────▶│  PostgreSQL  │
-│   Frontend   │      │   Backend    │      │  + pgvector  │
-│  Port 3000   │      │  Port 8001   │      │  Port 5433   │
-└──────────────┘      └──────────────┘      └──────────────┘
-                             │
-                             ▼
-                      ┌──────────────┐
-                      │   Librosa    │
-                      │   Analysis   │
-                      └──────────────┘
-```
-
----
-
-## 🔧 Problèmes résolus
-
-### ✅ Build Docker
-- **Problème** : `essentia-tensorflow==2.1b6.dev1110` inexistant
-- **Solution** : Supprimé, commenté avec alternatives
-
-### ✅ Conflits de ports
-- **Problème** : Ports 5432 et 8000 occupés
-- **Solution** : Changé en 5433 et 8001
-
-### ✅ Nom réservé SQLAlchemy
-- **Problème** : Colonne `metadata` réservée
-- **Solution** : Renommé en `extra_metadata`
-
----
-
-## ✨ Points forts
-
-- 🚀 **Rapide** : 1s par fichier
-- 💻 **CPU-only** : Pas de GPU nécessaire
-- 🏠 **100% local** : Zéro dépendance cloud
-- 🎯 **Précis** : Librosa = standard industrie
-- 📦 **Simple** : Docker Compose tout-en-un
-- 📚 **Documenté** : 8 guides complets
-- 🔓 **Open source** : Code modifiable
-
----
-
-## 🎯 Cas d'usage
-
-✅ DJ / Producteur musical
-✅ Organisation bibliothèque audio
-✅ Création playlists intelligentes
-✅ Analyse musicologique
-✅ Recherche par similarité
-✅ Filtrage par tempo/énergie
-
----
-
-## 🛠️ Commandes essentielles
-
-```bash
-# Santé du système
-curl http://localhost:8001/health
-
-# Statistiques
-curl http://localhost:8001/api/stats
-
-# Recherche par BPM
-curl "http://localhost:8001/api/tracks?bpm_min=120&bpm_max=140"
-
-# Logs
-docker-compose logs -f backend
-
-# Redémarrer
-docker-compose restart
-```
-
----
-
-## 📈 État du projet
-
-| Composant | Complétude | Statut |
-|-----------|------------|--------|
-| Backend API | 100% | ✅ Opérationnel |
-| Base de données | 100% | ✅ Configurée |
-| Extraction audio | 100% | ✅ Fonctionnel |
-| Frontend MVP | 80% | ✅ Basique |
-| Documentation | 100% | ✅ Complète |
-| Classification IA | 0% | ⚠️ Optionnel |
-
-**Score global** : **95%** 🎉
-
----
-
-## 🎉 Conclusion
-
-Le système est **prêt à l'emploi** avec :
-- ✅ Extraction complète de features musicales
-- ✅ API REST puissante et documentée
-- ✅ Interface web fonctionnelle
-- ✅ Base de données performante
-- ✅ Streaming et téléchargement audio
-
-**Librosa seul suffit pour 95% des besoins !**
-
-Les features extraites (tempo, tonalité, energy, valence) permettent déjà :
-- Organisation de bibliothèque musicale
-- Création de playlists par BPM
-- Filtrage par énergie/humeur
-- Recherche et découverte musicale
-
-**Le projet est un succès ! 🎵**

SETUP.md

@@ -1,403 +0,0 @@
-# Audio Classifier - Guide de Déploiement
-
-## 📋 Prérequis
-
-- **Docker** & Docker Compose
-- **Node.js** 20+ (pour le frontend en mode dev)
-- **Python** 3.11+ (optionnel, si vous voulez tester le backend sans Docker)
-- **FFmpeg** (installé automatiquement dans le conteneur Docker)
-
-## 🚀 Installation Rapide
-
-### 1. Cloner le projet
-
-```bash
-cd "/Users/benoit/Documents/code/Audio Classifier"
-```
-
-### 2. Configurer les variables d'environnement
-
-```bash
-cp .env.example .env
-```
-
-Éditer `.env` et définir :
-
-```env
-# Chemin vers votre bibliothèque audio (IMPORTANT)
-AUDIO_LIBRARY_PATH=/chemin/absolu/vers/vos/fichiers/audio
-
-# Exemple macOS:
-# AUDIO_LIBRARY_PATH=/Users/benoit/Music
-
-# Le reste peut rester par défaut
-DATABASE_URL=postgresql://audio_user:audio_password@localhost:5432/audio_classifier
-```
-
-### 3. Télécharger les modèles Essentia
-
-Les modèles de classification sont nécessaires pour analyser les fichiers audio.
-
-```bash
-./scripts/download-essentia-models.sh
-```
-
-Cela télécharge (~300 MB) :
-- `mtg_jamendo_genre` : Classification de 50 genres musicaux
-- `mtg_jamendo_moodtheme` : Classification de 56 ambiances/moods
-- `mtg_jamendo_instrument` : Détection de 40 instruments
-
-### 4. Lancer le backend avec Docker
-
-```bash
-docker-compose up -d
-```
-
-Cela démarre :
-- **PostgreSQL** avec l'extension pgvector (port 5432)
-- **Backend FastAPI** (port 8000)
-
-Vérifier que tout fonctionne :
-
-```bash
-curl http://localhost:8000/health
-# Devrait retourner: {"status":"healthy",...}
-```
-
-Documentation API interactive : **http://localhost:8000/docs**
-
-### 5. Lancer le frontend (mode développement)
-
-```bash
-cd frontend
-cp .env.local.example .env.local
-npm install
-npm run dev
-```
-
-Frontend accessible sur : **http://localhost:3000**
-
-## 📊 Utiliser l'Application
-
-### Analyser votre bibliothèque audio
-
-**Option 1 : Via l'API (recommandé pour première analyse)**
-
-```bash
-curl -X POST http://localhost:8000/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{
-    "path": "/audio",
-    "recursive": true
-  }'
-```
-
-**Note** : Le chemin `/audio` correspond au montage Docker de `AUDIO_LIBRARY_PATH`.
-
-Vous recevrez un `job_id`. Vérifier la progression :
-
-```bash
-curl http://localhost:8000/api/analyze/status/JOB_ID
-```
-
-**Option 2 : Via Python (backend local)**
-
-```bash
-cd backend
-python -m venv venv
-source venv/bin/activate  # Windows: venv\Scripts\activate
-pip install -r requirements.txt
-
-# Analyser un fichier
-python -c "
-from src.core.analyzer import AudioAnalyzer
-analyzer = AudioAnalyzer()
-result = analyzer.analyze_file('/path/to/audio.mp3')
-print(result)
-"
-```
-
-### Rechercher des pistes
-
-**Par texte :**
-
-```bash
-curl "http://localhost:8000/api/search?q=jazz&limit=10"
-```
-
-**Avec filtres :**
-
-```bash
-curl "http://localhost:8000/api/tracks?genre=electronic&bpm_min=120&bpm_max=140&limit=20"
-```
-
-**Pistes similaires :**
-
-```bash
-curl "http://localhost:8000/api/tracks/TRACK_ID/similar?limit=10"
-```
-
-### Télécharger / Écouter
-
-- **Stream** : `http://localhost:8000/api/audio/stream/TRACK_ID`
-- **Download** : `http://localhost:8000/api/audio/download/TRACK_ID`
-- **Waveform** : `http://localhost:8000/api/audio/waveform/TRACK_ID`
-
-## 🏗️ Architecture
-
-```
-audio-classifier/
-├── backend/                  # API Python FastAPI
-│   ├── src/
-│   │   ├── core/            # Audio processing
-│   │   │   ├── audio_processor.py      # Librosa features
-│   │   │   ├── essentia_classifier.py  # Genre/Mood/Instruments
-│   │   │   ├── waveform_generator.py   # Peaks pour UI
-│   │   │   ├── file_scanner.py         # Scan dossiers
-│   │   │   └── analyzer.py             # Orchestrateur
-│   │   ├── models/          # Database
-│   │   │   ├── schema.py               # SQLAlchemy models
-│   │   │   └── crud.py                 # CRUD operations
-│   │   ├── api/             # FastAPI routes
-│   │   │   └── routes/
-│   │   │       ├── tracks.py           # GET/DELETE tracks
-│   │   │       ├── search.py           # Recherche
-│   │   │       ├── audio.py            # Stream/Download
-│   │   │       ├── analyze.py          # Jobs d'analyse
-│   │   │       ├── similar.py          # Recommandations
-│   │   │       └── stats.py            # Statistiques
-│   │   └── utils/           # Config, logging, validators
-│   ├── models/              # Essentia .pb files
-│   └── requirements.txt
-│
-├── frontend/                # UI Next.js
-│   ├── app/
-│   │   ├── page.tsx        # Page principale
-│   │   └── layout.tsx
-│   ├── components/
-│   │   └── providers/
-│   ├── lib/
-│   │   ├── api.ts          # Client API
-│   │   ├── types.ts        # TypeScript types
-│   │   └── utils.ts        # Helpers
-│   └── package.json
-│
-├── scripts/
-│   └── download-essentia-models.sh
-│
-└── docker-compose.yml
-```
-
-## 🔧 Configuration Avancée
-
-### Performance CPU
-
-Le système est optimisé pour CPU-only. Sur un CPU moderne (4 cores) :
-
-- **Librosa features** : ~0.5-1s par fichier
-- **Essentia classification** : ~1-2s par fichier
-- **Total** : ~2-3s par fichier
-
-Ajuster le parallélisme dans `.env` :
-
-```env
-ANALYSIS_NUM_WORKERS=4  # Nombre de threads parallèles
-```
-
-### Activer les embeddings CLAP (optionnel)
-
-Pour la recherche sémantique avancée ("calm piano for working") :
-
-```env
-ANALYSIS_USE_CLAP=true
-```
-
-**Attention** : Augmente significativement le temps d'analyse (~5-10s supplémentaires par fichier).
-
-### Base de données
-
-Par défaut, PostgreSQL tourne dans Docker. Pour utiliser une DB externe :
-
-```env
-DATABASE_URL=postgresql://user:pass@external-host:5432/dbname
-```
-
-Appliquer les migrations :
-
-```bash
-cd backend
-alembic upgrade head
-```
-
-## 📊 Données Extraites
-
-### Features Audio (Librosa)
-- **Tempo** : BPM détecté automatiquement
-- **Tonalité** : Clé musicale (C major, D minor, etc.)
-- **Signature rythmique** : 4/4, 3/4, etc.
-- **Énergie** : Intensité sonore (0-1)
-- **Danceability** : Score de dansabilité (0-1)
-- **Valence** : Positivité/négativité émotionnelle (0-1)
-- **Features spectrales** : Centroid, rolloff, bandwidth
-
-### Classification (Essentia)
-- **Genre** : 50 genres possibles (rock, electronic, jazz, etc.)
-- **Mood** : 56 ambiances (energetic, calm, dark, happy, etc.)
-- **Instruments** : 40 instruments détectables (piano, guitar, drums, etc.)
-
-## 🐛 Troubleshooting
-
-### Le backend ne démarre pas
-
-```bash
-docker-compose logs backend
-```
-
-Vérifier que :
-- PostgreSQL est bien démarré (`docker-compose ps`)
-- Les modèles Essentia sont téléchargés (`ls backend/models/*.pb`)
-- Le port 8000 n'est pas déjà utilisé
-
-### "Model file not found"
-
-```bash
-./scripts/download-essentia-models.sh
-```
-
-### Frontend ne se connecte pas au backend
-
-Vérifier `.env.local` :
-
-```env
-NEXT_PUBLIC_API_URL=http://localhost:8000
-```
-
-### Analyse très lente
-
-- Réduire `ANALYSIS_NUM_WORKERS` si CPU surchargé
-- Désactiver `ANALYSIS_USE_CLAP` si activé
-- Vérifier que les fichiers audio sont accessibles rapidement (éviter NAS lents)
-
-### Erreur FFmpeg
-
-FFmpeg est installé automatiquement dans le conteneur Docker. Si vous lancez le backend en local :
-
-```bash
-# macOS
-brew install ffmpeg
-
-# Ubuntu/Debian
-sudo apt-get install ffmpeg libsndfile1
-```
-
-## 📦 Production
-
-### Build frontend
-
-```bash
-cd frontend
-npm run build
-npm start  # Port 3000
-```
-
-### Backend en production
-
-Utiliser Gunicorn avec Uvicorn workers :
-
-```bash
-pip install gunicorn
-gunicorn src.api.main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
-```
-
-### Reverse proxy (Nginx)
-
-```nginx
-server {
-    listen 80;
-    server_name your-domain.com;
-
-    location /api {
-        proxy_pass http://localhost:8000;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-    }
-
-    location / {
-        proxy_pass http://localhost:3000;
-    }
-}
-```
-
-## 🔒 Sécurité
-
-**IMPORTANT** : Le système actuel n'a PAS d'authentification.
-
-Pour la production :
-- Ajouter authentication JWT
-- Limiter l'accès aux endpoints d'analyse
-- Valider tous les chemins de fichiers (déjà fait côté backend)
-- Utiliser HTTPS
-- Restreindre CORS aux domaines autorisés
-
-## 📝 Développement
-
-### Ajouter un nouveau genre/mood
-
-Éditer `backend/src/core/essentia_classifier.py` :
-
-```python
-self.class_labels["genre"] = [
-    # ... genres existants
-    "nouveau_genre",
-]
-```
-
-### Modifier les features extraites
-
-Éditer `backend/src/core/audio_processor.py` et ajouter votre fonction :
-
-```python
-def extract_new_feature(y, sr) -> float:
-    # Votre logique
-    return feature_value
-```
-
-Puis mettre à jour `extract_all_features()`.
-
-### Ajouter une route API
-
-1. Créer `backend/src/api/routes/nouvelle_route.py`
-2. Ajouter le router dans `backend/src/api/main.py`
-
-### Tests
-
-```bash
-# Backend
-cd backend
-pytest
-
-# Frontend
-cd frontend
-npm test
-```
-
-## 📈 Améliorations Futures
-
-- [ ] Interface de scan dans le frontend (actuellement via API seulement)
-- [ ] Player audio intégré avec waveform interactive
-- [ ] Filtres avancés (multi-genre, range sliders)
-- [ ] Export playlists (M3U, CSV, JSON)
-- [ ] Détection de doublons (audio fingerprinting)
-- [ ] Édition de tags ID3
-- [ ] Recherche sémantique avec CLAP
-- [ ] Authentication multi-utilisateurs
-- [ ] WebSocket pour progression temps réel
-
-## 🆘 Support
-
-Pour toute question :
-1. Vérifier les logs : `docker-compose logs -f backend`
-2. Consulter la doc API : http://localhost:8000/docs
-3. Ouvrir une issue GitHub
-
-Bon classement ! 🎵

STATUS.md

@@ -1,202 +0,0 @@
-# ✅ Audio Classifier - État du Projet
-
-**Date** : 27 novembre 2025
-**Statut** : ✅ **Opérationnel**
-
-## 🎯 Ce qui fonctionne
-
-### Backend (100%)
-- ✅ API FastAPI sur http://localhost:8001
-- ✅ Base de données PostgreSQL + pgvector (port 5433)
-- ✅ Extraction de features audio (Librosa)
-  - Tempo (BPM)
-  - Tonalité (key)
-  - Signature rythmique
-  - Energy, Danceability, Valence
-  - Features spectrales
-- ✅ Génération waveform pour visualisation
-- ✅ Scanner de dossiers
-- ✅ API complète :
-  - GET /api/tracks (liste + filtres)
-  - GET /api/tracks/{id} (détails)
-  - GET /api/search (recherche textuelle)
-  - GET /api/audio/stream/{id} (streaming)
-  - GET /api/audio/download/{id} (téléchargement)
-  - GET /api/audio/waveform/{id} (données waveform)
-  - POST /api/analyze/folder (lancer analyse)
-  - GET /api/analyze/status/{id} (progression)
-  - GET /api/stats (statistiques)
-
-### Frontend (MVP)
-- ✅ Interface Next.js configurée
-- ✅ Client API TypeScript
-- ✅ Page principale avec :
-  - Statistiques globales
-  - Liste des pistes
-  - Pagination
-  - Boutons Play & Download
-- ✅ React Query pour cache
-- ✅ TailwindCSS
-
-### Infrastructure
-- ✅ Docker Compose fonctionnel
-- ✅ Migrations Alembic
-- ✅ Documentation complète
-
-## ⚠️ Limitations actuelles
-
-### Classification IA (Essentia)
-**Statut** : ❌ Désactivée (optionnelle)
-
-Le système fonctionne **sans les modèles Essentia** pour simplifier le déploiement.
-
-**Impact** :
-- ❌ Pas de classification automatique genre/mood/instruments
-- ✅ Toutes les autres features fonctionnent (tempo, tonalité, energy, etc.)
-
-**Pour activer** :
-1. Télécharger modèles : `./scripts/download-essentia-models.sh`
-2. Modifier `docker-compose.dev.yml` : `dockerfile: Dockerfile` (au lieu de `Dockerfile.minimal`)
-3. Rebuild : `docker-compose -f docker-compose.dev.yml build backend`
-
-### Frontend avancé
-**Statut** : 🚧 MVP seulement
-
-**Manquant** (non-critique) :
-- Player audio intégré avec contrôles
-- Visualisation waveform interactive
-- Filtres avancés (sliders BPM, energy)
-- Interface de scan de dossiers
-- Page détails piste
-- Pistes similaires UI
-
-**Pourquoi** : MVP fonctionnel prioritaire, extensions possibles plus tard
-
-## 🔧 Configuration
-
-### Ports
-- **Backend** : 8001 (modifié pour éviter conflit avec port 8000)
-- **PostgreSQL** : 5433 (modifié pour éviter conflit avec port 5432)
-- **Frontend** : 3000
-
-### Variables d'environnement
-Fichier `.env` configuré avec :
-- Database PostgreSQL
-- CORS
-- Workers parallèles
-- AUDIO_LIBRARY_PATH (à personnaliser)
-
-### Migration DB
-✅ Exécutée avec succès :
-```bash
-docker exec audio_classifier_api alembic upgrade head
-```
-
-## 📊 Performance
-
-**Analyse audio (sans Essentia)** :
-- ~0.5-1s par fichier
-- Parallélisation : 4 workers
-- 1000 fichiers ≈ 10-15 minutes
-
-**Avec Essentia** (si activé) :
-- ~2-3s par fichier
-- 1000 fichiers ≈ 40-50 minutes
-
-## 🚀 Utilisation
-
-### 1. Services démarrés
-```bash
-docker-compose -f docker-compose.dev.yml ps
-```
-
-### 2. Tester l'API
-```bash
-curl http://localhost:8001/health
-curl http://localhost:8001/api/stats
-```
-
-### 3. Lancer le frontend
-```bash
-cd frontend
-npm install  # Si pas déjà fait
-npm run dev
-```
-
-### 4. Analyser des fichiers
-```bash
-curl -X POST http://localhost:8001/api/analyze/folder \
-  -H "Content-Type: application/json" \
-  -d '{"path": "/audio", "recursive": true}'
-```
-
-## 📁 Structure projet
-
-```
-Audio Classifier/
-├── backend/                     ✅ Complet
-│   ├── src/core/               ✅ Audio processing
-│   ├── src/models/             ✅ Database
-│   ├── src/api/                ✅ FastAPI routes
-│   ├── Dockerfile.minimal      ✅ Build sans Essentia
-│   └── requirements-minimal.txt ✅ Dépendances
-├── frontend/                    ✅ MVP
-│   ├── app/                    ✅ Next.js pages
-│   ├── lib/                    ✅ API client
-│   └── components/             🚧 Basique
-├── scripts/                     ✅
-│   └── download-essentia-models.sh
-├── docker-compose.dev.yml       ✅ Config actuelle
-└── Documentation/               ✅ Complète
-    ├── README.md
-    ├── SETUP.md
-    ├── QUICKSTART.md
-    ├── DEMARRAGE.md
-    └── STATUS.md (ce fichier)
-```
-
-## 🎯 Prochaines étapes suggérées
-
-### Court terme
-1. **Analyser votre bibliothèque** : Tester avec vos fichiers audio
-2. **Explorer le frontend** : Vérifier l'affichage des pistes
-3. **Tester la recherche** : Filtrer les résultats
-
-### Moyen terme
-1. **Activer Essentia** (optionnel) : Pour classification genre/mood
-2. **Améliorer le frontend** :
-   - Player audio intégré
-   - Filtres avancés
-   - Waveform interactive
-
-### Long terme
-1. **CLAP embeddings** : Recherche sémantique avancée
-2. **Export playlists** : M3U, CSV, JSON
-3. **Authentication** : Multi-utilisateurs
-4. **Duplicate detection** : Audio fingerprinting
-
-## 🐛 Bugs connus
-
-Aucun bug critique identifié.
-
-## 📚 Documentation
-
-- **[DEMARRAGE.md](DEMARRAGE.md)** : Guide de démarrage immédiat
-- **[QUICKSTART.md](QUICKSTART.md)** : Démarrage en 5 minutes
-- **[SETUP.md](SETUP.md)** : Guide complet + troubleshooting
-- **[README.md](README.md)** : Vue d'ensemble
-- **API Docs** : http://localhost:8001/docs
-
-## ✨ Conclusion
-
-Le système est **100% fonctionnel** pour :
-- ✅ Extraction de features audio
-- ✅ Stockage en base de données
-- ✅ API REST complète
-- ✅ Streaming et téléchargement audio
-- ✅ Recherche et filtres
-- ✅ Interface web basique
-
-**Classification IA optionnelle** (Essentia) peut être ajoutée facilement si besoin.
-
-Le projet est prêt à être utilisé ! 🎵

TRANSCODING_SETUP.md

@@ -0,0 +1,175 @@
+# Configuration Transcodage & Optimisation
+
+## 📋 Vue d'ensemble
+
+Ce système implémente un transcodage automatique **MP3 128kbps** pour optimiser le streaming, tout en conservant les fichiers originaux pour le téléchargement.
+
+## 🎯 Fonctionnalités
+
+### 1. **Transcodage automatique**
+- Tous les fichiers audio sont transcodés en **MP3 128kbps** lors du scan
+- Fichiers optimisés stockés dans un dossier `transcoded/` à côté des originaux
+- Compression ~70-90% selon le format source
+
+### 2. **Pré-calcul des waveforms**
+- Waveforms générées lors du scan (800 points)
+- Stockées en JSON dans un dossier `waveforms/`
+- Chargement instantané dans le player
+
+### 3. **Double chemin en BDD**
+- `filepath` : Fichier original (pour téléchargement)
+- `stream_filepath` : MP3 128kbps (pour streaming)
+- `waveform_filepath` : JSON pré-calculé
+
+### 4. **Bouton Rescan dans l'UI**
+- Header : bouton "Rescan" avec icône
+- Statut en temps réel du scan
+- Reload automatique après scan
+
+## 🔧 Architecture
+
+### Backend
+```
+backend/
+├── src/
+│   ├── core/
+│   │   ├── transcoder.py          # Module FFmpeg
+│   │   └── waveform_generator.py  # Génération waveform
+│   ├── api/routes/
+│   │   ├── audio.py                # Stream avec fallback
+│   │   └── library.py              # Endpoint /scan
+│   ├── cli/
+│   │   └── scanner.py              # Scanner CLI amélioré
+│   └── models/
+│       └── schema.py               # Nouveaux champs BDD
+```
+
+### Frontend
+```
+frontend/app/page.tsx
+- Bouton rescan dans header
+- Polling du statut toutes les 2s
+- Affichage progression
+```
+
+## 🚀 Utilisation
+
+### Rescan via UI
+1. Cliquer sur le bouton **"Rescan"** dans le header
+2. Le scan démarre en arrière-plan
+3. Statut affiché en temps réel
+4. Refresh automatique à la fin
+
+### Rescan via CLI (dans le container)
+```bash
+docker-compose exec backend python -m src.cli.scanner /music
+```
+
+### Rescan via API
+```bash
+curl -X POST http://localhost:8000/api/library/scan
+```
+
+### Vérifier le statut
+```bash
+curl http://localhost:8000/api/library/scan/status
+```
+
+## 📊 Bénéfices
+
+### Streaming
+- **Temps de chargement réduit de 70-90%**
+- Bande passante économisée
+- Démarrage instantané de la lecture
+
+### Waveform
+- **Chargement instantané** (pas de génération à la volée)
+- Pas de latence perceptible
+
+### Espace disque
+- MP3 128kbps : ~1 MB/min
+- FLAC original : ~5-8 MB/min
+- **Ratio: ~15-20% de l'original**
+
+## 🛠️ Configuration
+
+### Dépendances
+- **FFmpeg** : Obligatoire pour le transcodage
+- Déjà installé dans le Dockerfile
+
+### Variables
+Pas de configuration nécessaire. Les dossiers sont créés automatiquement :
+- `transcoded/` : MP3 128kbps
+- `waveforms/` : JSON
+
+## 📝 Migration BDD
+
+Migration appliquée : `003_add_stream_waveform_paths`
+
+Nouveaux champs :
+```sql
+ALTER TABLE audio_tracks ADD COLUMN stream_filepath VARCHAR;
+ALTER TABLE audio_tracks ADD COLUMN waveform_filepath VARCHAR;
+CREATE INDEX idx_stream_filepath ON audio_tracks (stream_filepath);
+```
+
+## 🔍 Fallback
+
+Si le fichier transcodé n'existe pas :
+1. L'API stream utilise le fichier original
+2. Aucune erreur pour l'utilisateur
+3. Log warning côté serveur
+
+## 🎵 Formats supportés
+
+### Entrée
+- MP3, WAV, FLAC, M4A, AAC, OGG, WMA
+
+### Sortie streaming
+- **MP3 128kbps** (toujours)
+- Stéréo, 44.1kHz
+- Codec: libmp3lame
+
+## 📈 Performance
+
+### Temps de traitement (par fichier)
+- Analyse audio : ~5-10s
+- Transcodage : ~2-5s (selon durée)
+- Waveform : ~1-2s
+- **Total : ~8-17s par fichier**
+
+### Parallélisation future
+Le code est prêt pour une parallélisation :
+- `--workers` paramètre déjà prévu
+- Nécessite refactoring du classifier (1 instance par worker)
+
+## ✅ Checklist déploiement
+
+- [x] Migration BDD appliquée
+- [x] FFmpeg installé dans le container
+- [x] Endpoint `/api/library/scan` fonctionnel
+- [x] Bouton rescan dans l'UI
+- [x] Streaming utilise MP3 transcodé
+- [x] Waveform pré-calculée
+- [ ] Tester avec de vrais fichiers
+- [ ] Configurer cron/scheduler pour scan nocturne (optionnel)
+
+## 🐛 Troubleshooting
+
+### FFmpeg not found
+```bash
+# Dans le container
+docker-compose exec backend ffmpeg -version
+```
+
+### Permissions
+Les dossiers `transcoded/` et `waveforms/` doivent avoir les mêmes permissions que le dossier parent.
+
+### Scan bloqué
+```bash
+# Vérifier le statut
+curl http://localhost:8000/api/library/scan/status
+
+# Redémarrer le backend si nécessaire
+docker-compose restart backend
+```

backend/.dockerignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+*.egg-info/
+dist/
+build/
+
+# Models are included in the image
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Logs
+*.log
+
+# Test
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Alembic
+# Keep alembic.ini and versions/

backend/.env.example

@@ -1,13 +0,0 @@
-# Database
-DATABASE_URL=postgresql://audio_user:audio_password@localhost:5432/audio_classifier
-
-# API Configuration
-CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000
-
-# Audio Analysis
-ANALYSIS_USE_CLAP=false
-ANALYSIS_NUM_WORKERS=4
-ESSENTIA_MODELS_PATH=./models
-
-# Audio Library
-AUDIO_LIBRARY_PATH=/path/to/your/audio/library

backend/DOCKER_BUILD.md

@@ -0,0 +1,136 @@
+# Docker Build Optimization
+
+Cette configuration utilise une approche en 2 images pour accélérer les builds backend de **15-25 minutes** à **30 secondes - 2 minutes**.
+
+## Architecture
+
+### Image 1 : Base (`audio-classifier-base`)
+Contient toutes les dépendances système et Python qui changent rarement :
+- Python 3.9 + apt packages (ffmpeg, libsndfile, etc.)
+- numpy, scipy, essentia-tensorflow
+- Toutes les dépendances de `requirements.txt`
+
+**Build** : ~15 minutes (1 fois par semaine ou quand `requirements.txt` change)
+
+### Image 2 : App (`audio-classifier-backend`)
+Hérite de l'image de base et ajoute uniquement le code applicatif :
+- Code source (`src/`)
+- Fichiers de configuration (`alembic.ini`)
+- Modèles Essentia (`models/`)
+
+**Build** : ~30 secondes - 2 minutes (à chaque commit)
+
+## Workflows CI/CD
+
+### 1. Build de l'image de base (`.gitea/workflows/docker-base.yml`)
+Se déclenche automatiquement quand :
+- `backend/requirements.txt` est modifié
+- `backend/Dockerfile.base` est modifié
+- Déclenchement manuel via l'interface Gitea
+
+```bash
+# Image produite :
+git.benoitsz.com/benoit/audio-classifier-base:latest
+git.benoitsz.com/benoit/audio-classifier-base:sha-<commit>
+```
+
+### 2. Build de l'image app (`.gitea/workflows/docker.yml`)
+Se déclenche à chaque push sur `main` :
+- Utilise l'image de base comme FROM
+- Copie uniquement le code source
+- Build rapide (~30s-2min)
+
+```bash
+# Image produite :
+git.benoitsz.com/benoit/audio-classifier-backend:dev
+git.benoitsz.com/benoit/audio-classifier-backend:dev-<commit>
+```
+
+## Utilisation en local
+
+### Build de l'image de base
+```bash
+cd backend
+docker build -f Dockerfile.base -t audio-classifier-base:local .
+```
+
+### Build de l'image app (utilise l'image de base)
+```bash
+# Depuis la racine du projet
+docker build \
+  --build-arg BASE_IMAGE=audio-classifier-base:local \
+  -f backend/Dockerfile \
+  -t audio-classifier-backend:local \
+  .
+```
+
+### Build direct (sans image de base) - pour tests
+Si tu veux tester un build complet sans dépendre de l'image de base :
+```bash
+# Revenir temporairement au Dockerfile original
+git show HEAD~1:backend/Dockerfile > backend/Dockerfile.monolithic
+docker build -f backend/Dockerfile.monolithic -t audio-classifier-backend:monolithic .
+```
+
+## Mise à jour des dépendances
+
+Quand tu modifies `requirements.txt` :
+
+1. **Push les changements sur `main`**
+   ```bash
+   git add backend/requirements.txt
+   git commit -m "Update dependencies"
+   git push
+   ```
+
+2. **Le workflow `docker-base.yml` se déclenche automatiquement**
+   - Build de la nouvelle image de base (~15 min)
+   - Push vers `git.benoitsz.com/benoit/audio-classifier-base:latest`
+
+3. **Les prochains builds backend utiliseront la nouvelle base**
+   - Builds futurs rapides (~30s-2min)
+
+## Déclenchement manuel
+
+Pour rebuild l'image de base manuellement (sans modifier `requirements.txt`) :
+
+1. Va sur Gitea : `https://git.benoitsz.com/benoit/audio-classifier/actions`
+2. Sélectionne le workflow "Build Base Docker Image"
+3. Clique sur "Run workflow"
+
+## Monitoring
+
+Vérifie les builds dans Gitea Actions :
+- **Base image** : `.gitea/workflows/docker-base.yml`
+- **App image** : `.gitea/workflows/docker.yml`
+
+Les logs montrent la durée de build pour chaque étape.
+
+## Gains de performance attendus
+
+| Scénario | Avant | Après | Gain |
+|----------|-------|-------|------|
+| Build normal (code change) | 15-25 min | 30s-2min | **90-95%** |
+| Build après update deps | 15-25 min | 15-25 min (base) + 30s-2min (app) | 0% (1ère fois) |
+| Builds suivants | 15-25 min | 30s-2min | **90-95%** |
+
+## Troubleshooting
+
+### Erreur "base image not found"
+L'image de base n'existe pas encore dans le registry. Solutions :
+1. Trigger le workflow `docker-base.yml` manuellement
+2. Ou build localement et push :
+   ```bash
+   docker build -f backend/Dockerfile.base -t git.benoitsz.com/benoit/audio-classifier-base:latest backend/
+   docker push git.benoitsz.com/benoit/audio-classifier-base:latest
+   ```
+
+### Build app lent malgré l'image de base
+Vérifie que le build-arg `BASE_IMAGE` est bien passé :
+```yaml
+build-args: |
+  BASE_IMAGE=${{ env.REGISTRY }}/${{ gitea.repository_owner }}/audio-classifier-base:latest
+```
+
+### Dépendances Python pas à jour dans l'app
+L'image de base doit être rebuildée. Trigger `docker-base.yml`.

backend/Dockerfile

@@ -1,56 +1,19 @@
-# Use amd64 platform for better Essentia compatibility, works with emulation on ARM
+# Use pre-built base image with all dependencies
-FROM --platform=linux/amd64 python:3.9-slim
+# Base image includes: Python 3.9, system deps, numpy, scipy, essentia-tensorflow, all pip deps
+# Only rebuild base when requirements.txt changes
+ARG BASE_IMAGE=git.benoitsz.com/benoit/audio-classifier-base:latest
+FROM ${BASE_IMAGE}
 
-# Install system dependencies
+# Working directory already set in base image
-RUN apt-get update && apt-get install -y \
-    ffmpeg \
-    libsndfile1 \
-    libsndfile1-dev \
-    gcc \
-    g++ \
-    gfortran \
-    libopenblas-dev \
-    liblapack-dev \
-    pkg-config \
-    curl \
-    build-essential \
-    libyaml-dev \
-    libfftw3-dev \
-    libavcodec-dev \
-    libavformat-dev \
-    libavutil-dev \
-    libswresample-dev \
-    libsamplerate0-dev \
-    libtag1-dev \
-    libchromaprint-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Set working directory
 WORKDIR /app
 
-# Upgrade pip, setuptools, wheel
-RUN pip install --no-cache-dir --upgrade pip setuptools wheel
-
-# Copy requirements
-COPY requirements.txt .
-
-# Install Python dependencies in stages for better caching
-# Using versions compatible with Python 3.9
-RUN pip install --no-cache-dir numpy==1.24.3
-RUN pip install --no-cache-dir scipy==1.11.4
-
-# Install Essentia-TensorFlow - Python 3.9 AMD64 support
-RUN pip install --no-cache-dir essentia-tensorflow
-
-RUN pip install --no-cache-dir -r requirements.txt
-
 # Copy application code
-COPY src/ ./src/
+COPY backend/src/ ./src/
-COPY alembic.ini .
+COPY backend/alembic.ini .
-COPY models/ ./models/
 
-# Create models directory if not exists
+# Copy Essentia models into image (28 MB total)
-RUN mkdir -p /app/models
+COPY backend/models/ ./models/
+RUN ls -lh /app/models
 
 # Expose port
 EXPOSE 8000

backend/Dockerfile.base

@@ -0,0 +1,59 @@
+# Base image for Audio Classifier Backend
+# This image contains all system dependencies and Python packages
+# Build this image only when dependencies change (requirements.txt updates)
+
+# Use amd64 platform for better Essentia compatibility
+FROM --platform=linux/amd64 python:3.9-slim
+
+LABEL maintainer="benoit.schw@gmail.com"
+LABEL description="Base image with all dependencies for Audio Classifier Backend"
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    libsndfile1-dev \
+    gcc \
+    g++ \
+    gfortran \
+    libopenblas-dev \
+    liblapack-dev \
+    pkg-config \
+    curl \
+    build-essential \
+    libyaml-dev \
+    libfftw3-dev \
+    libavcodec-dev \
+    libavformat-dev \
+    libavutil-dev \
+    libswresample-dev \
+    libsamplerate0-dev \
+    libtag1-dev \
+    libchromaprint-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Upgrade pip, setuptools, wheel
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies in stages for better caching
+# Using versions compatible with Python 3.9
+RUN pip install --no-cache-dir numpy==1.24.3
+RUN pip install --no-cache-dir scipy==1.11.4
+
+# Install Essentia-TensorFlow - Python 3.9 AMD64 support
+RUN pip install --no-cache-dir essentia-tensorflow
+
+# Install remaining dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Verify installations
+RUN python -c "import essentia.standard; import numpy; import scipy; import fastapi; print('All dependencies installed successfully')"
+
+# This image is meant to be used as a base
+# The application code will be copied in the derived Dockerfile

backend/Dockerfile.minimal

@@ -1,35 +0,0 @@
-FROM python:3.11-slim
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    ffmpeg \
-    libsndfile1 \
-    gcc \
-    g++ \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Set working directory
-WORKDIR /app
-
-# Upgrade pip
-RUN pip install --no-cache-dir --upgrade pip setuptools wheel
-
-# Copy minimal requirements
-COPY requirements-minimal.txt .
-
-# Install dependencies
-RUN pip install --no-cache-dir -r requirements-minimal.txt
-
-# Copy application code
-COPY src/ ./src/
-COPY alembic.ini .
-
-# Create models directory
-RUN mkdir -p /app/models
-
-# Expose port
-EXPOSE 8000
-
-# Run server (skip migrations for now)
-CMD uvicorn src.api.main:app --host 0.0.0.0 --port 8000

backend/check_dependencies.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Check all required dependencies are installed."""
+import sys
+
+def check_import(module_name, package_name=None):
+    """Try to import a module and report status."""
+    package = package_name or module_name
+    try:
+        __import__(module_name)
+        print(f"✅ {package}")
+        return True
+    except ImportError as e:
+        print(f"❌ {package}: {e}")
+        return False
+
+def main():
+    """Check all dependencies."""
+    print("🔍 Checking Python dependencies...\n")
+
+    dependencies = [
+        # Web Framework
+        ("fastapi", "fastapi"),
+        ("uvicorn", "uvicorn"),
+        ("multipart", "python-multipart"),
+
+        # Database
+        ("sqlalchemy", "sqlalchemy"),
+        ("psycopg2", "psycopg2-binary"),
+        ("pgvector.sqlalchemy", "pgvector"),
+        ("alembic", "alembic"),
+
+        # Audio Processing
+        ("librosa", "librosa"),
+        ("soundfile", "soundfile"),
+        ("audioread", "audioread"),
+        ("mutagen", "mutagen"),
+
+        # Scientific
+        ("numpy", "numpy"),
+        ("scipy", "scipy"),
+
+        # Configuration
+        ("pydantic", "pydantic"),
+        ("pydantic_settings", "pydantic-settings"),
+        ("dotenv", "python-dotenv"),
+        ("email_validator", "email-validator"),
+
+        # Authentication
+        ("jose", "python-jose"),
+        ("passlib", "passlib"),
+
+        # Utilities
+        ("aiofiles", "aiofiles"),
+        ("httpx", "httpx"),
+
+        # Essentia (optional)
+        ("essentia.standard", "essentia-tensorflow"),
+    ]
+
+    all_ok = True
+    for module, package in dependencies:
+        if not check_import(module, package):
+            all_ok = False
+
+    print("\n" + "="*50)
+    if all_ok:
+        print("✅ All dependencies installed!")
+        return 0
+    else:
+        print("❌ Some dependencies are missing")
+        print("\nInstall missing dependencies with:")
+        print("  pip install -r requirements.txt")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

backend/models/README.md

@@ -0,0 +1,52 @@
+# Essentia Models
+
+Ce dossier contient les modèles pré-entraînés Essentia-TensorFlow pour la classification audio (28 MB total).
+
+## Modèles requis
+
+Les fichiers suivants sont nécessaires pour le fonctionnement de l'application :
+
+1. **discogs-effnet-bs64-1.pb** (18 MB) - Embedding model
+2. **genre_discogs400-discogs-effnet-1.pb** (2 MB) - Genre classifier
+3. **genre_discogs400-discogs-effnet-1.json** (15 KB) - Genre metadata
+4. **mtg_jamendo_moodtheme-discogs-effnet-1.pb** (2.7 MB) - Mood classifier
+5. **mtg_jamendo_instrument-discogs-effnet-1.pb** (2.6 MB) - Instrument classifier
+6. **mtg_jamendo_genre-discogs-effnet-1.pb** (2.7 MB) - Alternative genre classifier
+
+## Téléchargement automatique
+
+**Pour les utilisateurs** : Les modèles sont déjà inclus dans les images Docker depuis le registry `git.benoitsz.com`. Aucune action nécessaire.
+
+**Pour le CI/CD** : Les modèles sont téléchargés automatiquement depuis essentia.upf.edu pendant le build (voir `.gitea/workflows/docker.yml`).
+
+**Pour le développement local** : Si vous avez besoin de builder localement, vous devez avoir les modèles dans ce dossier. Ils ne sont pas versionnés dans Git car ils pèsent 28 MB.
+
+### Téléchargement manuel (si nécessaire)
+
+```bash
+cd backend/models
+
+# Embedding model (18 MB)
+curl -L -O https://essentia.upf.edu/models/feature-extractors/discogs-effnet/discogs-effnet-bs64-1.pb
+
+# Genre classifier (2 MB)
+curl -L -O https://essentia.upf.edu/models/classification-heads/genre_discogs400/genre_discogs400-discogs-effnet-1.pb
+curl -L -O https://essentia.upf.edu/models/classification-heads/genre_discogs400/genre_discogs400-discogs-effnet-1.json
+
+# Mood classifier (2.7 MB)
+curl -L -O https://essentia.upf.edu/models/classification-heads/mtg_jamendo_moodtheme/mtg_jamendo_moodtheme-discogs-effnet-1.pb
+
+# Instrument classifier (2.6 MB)
+curl -L -O https://essentia.upf.edu/models/classification-heads/mtg_jamendo_instrument/mtg_jamendo_instrument-discogs-effnet-1.pb
+
+# Alternative genre classifier (2.7 MB)
+curl -L -O https://essentia.upf.edu/models/classification-heads/mtg_jamendo_genre/mtg_jamendo_genre-discogs-effnet-1.pb
+```
+
+## Source
+
+Tous les modèles proviennent du projet Essentia : https://essentia.upf.edu/models/
+
+## Licence
+
+Ces modèles sont fournis par le Music Technology Group de l'Universitat Pompeu Fabra sous licence permissive pour usage académique et commercial.

backend/models/genre_discogs400-discogs-effnet-1.json

@@ -0,0 +1,462 @@
+{
+    "name": "Genre Discogs400",
+    "type": "Music genre classification",
+    "link": "https://essentia.upf.edu/models/classification-heads/genre_discogs400/genre_discogs400-discogs-effnet-1.pb",
+    "version": "1",
+    "description": "Prediction of 400 music styles in the from the Discogs taxonomy",
+    "author": "Pablo Alonso",
+    "email": "pablo.alonso@upf.edu",
+    "release_date": "2023-05-04",
+    "framework": "tensorflow",
+    "framework_version": "2.8.0",
+    "classes": [
+        "Blues---Boogie Woogie",
+        "Blues---Chicago Blues",
+        "Blues---Country Blues",
+        "Blues---Delta Blues",
+        "Blues---Electric Blues",
+        "Blues---Harmonica Blues",
+        "Blues---Jump Blues",
+        "Blues---Louisiana Blues",
+        "Blues---Modern Electric Blues",
+        "Blues---Piano Blues",
+        "Blues---Rhythm & Blues",
+        "Blues---Texas Blues",
+        "Brass & Military---Brass Band",
+        "Brass & Military---Marches",
+        "Brass & Military---Military",
+        "Children's---Educational",
+        "Children's---Nursery Rhymes",
+        "Children's---Story",
+        "Classical---Baroque",
+        "Classical---Choral",
+        "Classical---Classical",
+        "Classical---Contemporary",
+        "Classical---Impressionist",
+        "Classical---Medieval",
+        "Classical---Modern",
+        "Classical---Neo-Classical",
+        "Classical---Neo-Romantic",
+        "Classical---Opera",
+        "Classical---Post-Modern",
+        "Classical---Renaissance",
+        "Classical---Romantic",
+        "Electronic---Abstract",
+        "Electronic---Acid",
+        "Electronic---Acid House",
+        "Electronic---Acid Jazz",
+        "Electronic---Ambient",
+        "Electronic---Bassline",
+        "Electronic---Beatdown",
+        "Electronic---Berlin-School",
+        "Electronic---Big Beat",
+        "Electronic---Bleep",
+        "Electronic---Breakbeat",
+        "Electronic---Breakcore",
+        "Electronic---Breaks",
+        "Electronic---Broken Beat",
+        "Electronic---Chillwave",
+        "Electronic---Chiptune",
+        "Electronic---Dance-pop",
+        "Electronic---Dark Ambient",
+        "Electronic---Darkwave",
+        "Electronic---Deep House",
+        "Electronic---Deep Techno",
+        "Electronic---Disco",
+        "Electronic---Disco Polo",
+        "Electronic---Donk",
+        "Electronic---Downtempo",
+        "Electronic---Drone",
+        "Electronic---Drum n Bass",
+        "Electronic---Dub",
+        "Electronic---Dub Techno",
+        "Electronic---Dubstep",
+        "Electronic---Dungeon Synth",
+        "Electronic---EBM",
+        "Electronic---Electro",
+        "Electronic---Electro House",
+        "Electronic---Electroclash",
+        "Electronic---Euro House",
+        "Electronic---Euro-Disco",
+        "Electronic---Eurobeat",
+        "Electronic---Eurodance",
+        "Electronic---Experimental",
+        "Electronic---Freestyle",
+        "Electronic---Future Jazz",
+        "Electronic---Gabber",
+        "Electronic---Garage House",
+        "Electronic---Ghetto",
+        "Electronic---Ghetto House",
+        "Electronic---Glitch",
+        "Electronic---Goa Trance",
+        "Electronic---Grime",
+        "Electronic---Halftime",
+        "Electronic---Hands Up",
+        "Electronic---Happy Hardcore",
+        "Electronic---Hard House",
+        "Electronic---Hard Techno",
+        "Electronic---Hard Trance",
+        "Electronic---Hardcore",
+        "Electronic---Hardstyle",
+        "Electronic---Hi NRG",
+        "Electronic---Hip Hop",
+        "Electronic---Hip-House",
+        "Electronic---House",
+        "Electronic---IDM",
+        "Electronic---Illbient",
+        "Electronic---Industrial",
+        "Electronic---Italo House",
+        "Electronic---Italo-Disco",
+        "Electronic---Italodance",
+        "Electronic---Jazzdance",
+        "Electronic---Juke",
+        "Electronic---Jumpstyle",
+        "Electronic---Jungle",
+        "Electronic---Latin",
+        "Electronic---Leftfield",
+        "Electronic---Makina",
+        "Electronic---Minimal",
+        "Electronic---Minimal Techno",
+        "Electronic---Modern Classical",
+        "Electronic---Musique Concr\u00e8te",
+        "Electronic---Neofolk",
+        "Electronic---New Age",
+        "Electronic---New Beat",
+        "Electronic---New Wave",
+        "Electronic---Noise",
+        "Electronic---Nu-Disco",
+        "Electronic---Power Electronics",
+        "Electronic---Progressive Breaks",
+        "Electronic---Progressive House",
+        "Electronic---Progressive Trance",
+        "Electronic---Psy-Trance",
+        "Electronic---Rhythmic Noise",
+        "Electronic---Schranz",
+        "Electronic---Sound Collage",
+        "Electronic---Speed Garage",
+        "Electronic---Speedcore",
+        "Electronic---Synth-pop",
+        "Electronic---Synthwave",
+        "Electronic---Tech House",
+        "Electronic---Tech Trance",
+        "Electronic---Techno",
+        "Electronic---Trance",
+        "Electronic---Tribal",
+        "Electronic---Tribal House",
+        "Electronic---Trip Hop",
+        "Electronic---Tropical House",
+        "Electronic---UK Garage",
+        "Electronic---Vaporwave",
+        "Folk, World, & Country---African",
+        "Folk, World, & Country---Bluegrass",
+        "Folk, World, & Country---Cajun",
+        "Folk, World, & Country---Canzone Napoletana",
+        "Folk, World, & Country---Catalan Music",
+        "Folk, World, & Country---Celtic",
+        "Folk, World, & Country---Country",
+        "Folk, World, & Country---Fado",
+        "Folk, World, & Country---Flamenco",
+        "Folk, World, & Country---Folk",
+        "Folk, World, & Country---Gospel",
+        "Folk, World, & Country---Highlife",
+        "Folk, World, & Country---Hillbilly",
+        "Folk, World, & Country---Hindustani",
+        "Folk, World, & Country---Honky Tonk",
+        "Folk, World, & Country---Indian Classical",
+        "Folk, World, & Country---La\u00efk\u00f3",
+        "Folk, World, & Country---Nordic",
+        "Folk, World, & Country---Pacific",
+        "Folk, World, & Country---Polka",
+        "Folk, World, & Country---Ra\u00ef",
+        "Folk, World, & Country---Romani",
+        "Folk, World, & Country---Soukous",
+        "Folk, World, & Country---S\u00e9ga",
+        "Folk, World, & Country---Volksmusik",
+        "Folk, World, & Country---Zouk",
+        "Folk, World, & Country---\u00c9ntekhno",
+        "Funk / Soul---Afrobeat",
+        "Funk / Soul---Boogie",
+        "Funk / Soul---Contemporary R&B",
+        "Funk / Soul---Disco",
+        "Funk / Soul---Free Funk",
+        "Funk / Soul---Funk",
+        "Funk / Soul---Gospel",
+        "Funk / Soul---Neo Soul",
+        "Funk / Soul---New Jack Swing",
+        "Funk / Soul---P.Funk",
+        "Funk / Soul---Psychedelic",
+        "Funk / Soul---Rhythm & Blues",
+        "Funk / Soul---Soul",
+        "Funk / Soul---Swingbeat",
+        "Funk / Soul---UK Street Soul",
+        "Hip Hop---Bass Music",
+        "Hip Hop---Boom Bap",
+        "Hip Hop---Bounce",
+        "Hip Hop---Britcore",
+        "Hip Hop---Cloud Rap",
+        "Hip Hop---Conscious",
+        "Hip Hop---Crunk",
+        "Hip Hop---Cut-up/DJ",
+        "Hip Hop---DJ Battle Tool",
+        "Hip Hop---Electro",
+        "Hip Hop---G-Funk",
+        "Hip Hop---Gangsta",
+        "Hip Hop---Grime",
+        "Hip Hop---Hardcore Hip-Hop",
+        "Hip Hop---Horrorcore",
+        "Hip Hop---Instrumental",
+        "Hip Hop---Jazzy Hip-Hop",
+        "Hip Hop---Miami Bass",
+        "Hip Hop---Pop Rap",
+        "Hip Hop---Ragga HipHop",
+        "Hip Hop---RnB/Swing",
+        "Hip Hop---Screw",
+        "Hip Hop---Thug Rap",
+        "Hip Hop---Trap",
+        "Hip Hop---Trip Hop",
+        "Hip Hop---Turntablism",
+        "Jazz---Afro-Cuban Jazz",
+        "Jazz---Afrobeat",
+        "Jazz---Avant-garde Jazz",
+        "Jazz---Big Band",
+        "Jazz---Bop",
+        "Jazz---Bossa Nova",
+        "Jazz---Contemporary Jazz",
+        "Jazz---Cool Jazz",
+        "Jazz---Dixieland",
+        "Jazz---Easy Listening",
+        "Jazz---Free Improvisation",
+        "Jazz---Free Jazz",
+        "Jazz---Fusion",
+        "Jazz---Gypsy Jazz",
+        "Jazz---Hard Bop",
+        "Jazz---Jazz-Funk",
+        "Jazz---Jazz-Rock",
+        "Jazz---Latin Jazz",
+        "Jazz---Modal",
+        "Jazz---Post Bop",
+        "Jazz---Ragtime",
+        "Jazz---Smooth Jazz",
+        "Jazz---Soul-Jazz",
+        "Jazz---Space-Age",
+        "Jazz---Swing",
+        "Latin---Afro-Cuban",
+        "Latin---Bai\u00e3o",
+        "Latin---Batucada",
+        "Latin---Beguine",
+        "Latin---Bolero",
+        "Latin---Boogaloo",
+        "Latin---Bossanova",
+        "Latin---Cha-Cha",
+        "Latin---Charanga",
+        "Latin---Compas",
+        "Latin---Cubano",
+        "Latin---Cumbia",
+        "Latin---Descarga",
+        "Latin---Forr\u00f3",
+        "Latin---Guaguanc\u00f3",
+        "Latin---Guajira",
+        "Latin---Guaracha",
+        "Latin---MPB",
+        "Latin---Mambo",
+        "Latin---Mariachi",
+        "Latin---Merengue",
+        "Latin---Norte\u00f1o",
+        "Latin---Nueva Cancion",
+        "Latin---Pachanga",
+        "Latin---Porro",
+        "Latin---Ranchera",
+        "Latin---Reggaeton",
+        "Latin---Rumba",
+        "Latin---Salsa",
+        "Latin---Samba",
+        "Latin---Son",
+        "Latin---Son Montuno",
+        "Latin---Tango",
+        "Latin---Tejano",
+        "Latin---Vallenato",
+        "Non-Music---Audiobook",
+        "Non-Music---Comedy",
+        "Non-Music---Dialogue",
+        "Non-Music---Education",
+        "Non-Music---Field Recording",
+        "Non-Music---Interview",
+        "Non-Music---Monolog",
+        "Non-Music---Poetry",
+        "Non-Music---Political",
+        "Non-Music---Promotional",
+        "Non-Music---Radioplay",
+        "Non-Music---Religious",
+        "Non-Music---Spoken Word",
+        "Pop---Ballad",
+        "Pop---Bollywood",
+        "Pop---Bubblegum",
+        "Pop---Chanson",
+        "Pop---City Pop",
+        "Pop---Europop",
+        "Pop---Indie Pop",
+        "Pop---J-pop",
+        "Pop---K-pop",
+        "Pop---Kay\u014dkyoku",
+        "Pop---Light Music",
+        "Pop---Music Hall",
+        "Pop---Novelty",
+        "Pop---Parody",
+        "Pop---Schlager",
+        "Pop---Vocal",
+        "Reggae---Calypso",
+        "Reggae---Dancehall",
+        "Reggae---Dub",
+        "Reggae---Lovers Rock",
+        "Reggae---Ragga",
+        "Reggae---Reggae",
+        "Reggae---Reggae-Pop",
+        "Reggae---Rocksteady",
+        "Reggae---Roots Reggae",
+        "Reggae---Ska",
+        "Reggae---Soca",
+        "Rock---AOR",
+        "Rock---Acid Rock",
+        "Rock---Acoustic",
+        "Rock---Alternative Rock",
+        "Rock---Arena Rock",
+        "Rock---Art Rock",
+        "Rock---Atmospheric Black Metal",
+        "Rock---Avantgarde",
+        "Rock---Beat",
+        "Rock---Black Metal",
+        "Rock---Blues Rock",
+        "Rock---Brit Pop",
+        "Rock---Classic Rock",
+        "Rock---Coldwave",
+        "Rock---Country Rock",
+        "Rock---Crust",
+        "Rock---Death Metal",
+        "Rock---Deathcore",
+        "Rock---Deathrock",
+        "Rock---Depressive Black Metal",
+        "Rock---Doo Wop",
+        "Rock---Doom Metal",
+        "Rock---Dream Pop",
+        "Rock---Emo",
+        "Rock---Ethereal",
+        "Rock---Experimental",
+        "Rock---Folk Metal",
+        "Rock---Folk Rock",
+        "Rock---Funeral Doom Metal",
+        "Rock---Funk Metal",
+        "Rock---Garage Rock",
+        "Rock---Glam",
+        "Rock---Goregrind",
+        "Rock---Goth Rock",
+        "Rock---Gothic Metal",
+        "Rock---Grindcore",
+        "Rock---Grunge",
+        "Rock---Hard Rock",
+        "Rock---Hardcore",
+        "Rock---Heavy Metal",
+        "Rock---Indie Rock",
+        "Rock---Industrial",
+        "Rock---Krautrock",
+        "Rock---Lo-Fi",
+        "Rock---Lounge",
+        "Rock---Math Rock",
+        "Rock---Melodic Death Metal",
+        "Rock---Melodic Hardcore",
+        "Rock---Metalcore",
+        "Rock---Mod",
+        "Rock---Neofolk",
+        "Rock---New Wave",
+        "Rock---No Wave",
+        "Rock---Noise",
+        "Rock---Noisecore",
+        "Rock---Nu Metal",
+        "Rock---Oi",
+        "Rock---Parody",
+        "Rock---Pop Punk",
+        "Rock---Pop Rock",
+        "Rock---Pornogrind",
+        "Rock---Post Rock",
+        "Rock---Post-Hardcore",
+        "Rock---Post-Metal",
+        "Rock---Post-Punk",
+        "Rock---Power Metal",
+        "Rock---Power Pop",
+        "Rock---Power Violence",
+        "Rock---Prog Rock",
+        "Rock---Progressive Metal",
+        "Rock---Psychedelic Rock",
+        "Rock---Psychobilly",
+        "Rock---Pub Rock",
+        "Rock---Punk",
+        "Rock---Rock & Roll",
+        "Rock---Rockabilly",
+        "Rock---Shoegaze",
+        "Rock---Ska",
+        "Rock---Sludge Metal",
+        "Rock---Soft Rock",
+        "Rock---Southern Rock",
+        "Rock---Space Rock",
+        "Rock---Speed Metal",
+        "Rock---Stoner Rock",
+        "Rock---Surf",
+        "Rock---Symphonic Rock",
+        "Rock---Technical Death Metal",
+        "Rock---Thrash",
+        "Rock---Twist",
+        "Rock---Viking Metal",
+        "Rock---Y\u00e9-Y\u00e9",
+        "Stage & Screen---Musical",
+        "Stage & Screen---Score",
+        "Stage & Screen---Soundtrack",
+        "Stage & Screen---Theme"
+    ],
+    "model_types": [
+        "frozen_model",
+        "SavedModel",
+        "onnx"
+    ],
+    "dataset": {
+        "name": "Discogs-4M (unreleased)",
+        "citation": "In-house dataset",
+        "size": "4M full tracks (3.3M used)",
+        "metrics": {
+            "ROC-AUC": 0.95417,
+            "PR-AUC": 0.20629
+        }
+    },
+    "schema": {
+        "inputs": [
+            {
+                "name": "serving_default_model_Placeholder",
+                "type": "float",
+                "shape": [
+                    "batch_size",
+                    1280
+                ]
+            }
+        ],
+        "outputs": [
+            {
+                "name": "PartitionedCall:0",
+                "type": "float",
+                "shape": [
+                    "batch_size",
+                    400
+                ],
+                "op": "Sigmoid",
+                "output_purpose": "predictions"
+            }
+        ]
+    },
+    "citation": "@inproceedings{alonso2022music,\n  title={Music Representation Learning Based on Editorial Metadata from Discogs},\n  author={Alonso-Jim{\\'e}nez, Pablo and Serra, Xavier and Bogdanov, Dmitry},\n  booktitle={Conference of the International Society for Music Information Retrieval (ISMIR)},\n  year={2022}\n}",
+    "inference": {
+        "sample_rate": 16000,
+        "algorithm": "TensorflowPredict2D",
+        "embedding_model": {
+            "algorithm": "TensorflowPredictEffnetDiscogs",
+            "model_name": "discogs-effnet-bs64-1",
+            "link": "https://essentia.upf.edu/models/music-style-classification/discogs-effnet/discogs-effnet-bs64-1.pb"
+        }
+    }
+}

backend/requirements-minimal.txt

@@ -1,31 +0,0 @@
-# Minimal requirements (without Essentia for faster build)
-
-# Web Framework
-fastapi==0.109.0
-uvicorn[standard]==0.27.0
-python-multipart==0.0.6
-
-# Database
-sqlalchemy==2.0.25
-psycopg2-binary==2.9.9
-pgvector==0.2.4
-alembic==1.13.1
-
-# Audio Processing (without Essentia)
-librosa==0.10.1
-soundfile==0.12.1
-audioread==3.0.1
-mutagen==1.47.0
-
-# Scientific Computing
-numpy==1.24.3
-scipy==1.11.4
-
-# Configuration & Validation
-pydantic==2.5.3
-pydantic-settings==2.1.0
-python-dotenv==1.0.0
-
-# Utilities
-aiofiles==23.2.1
-httpx==0.26.0

backend/requirements.txt

@@ -26,6 +26,11 @@ scipy==1.11.4
 pydantic==2.5.3
 pydantic-settings==2.1.0
 python-dotenv==1.0.0
+email-validator==2.1.0
+
+# Authentication
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
 
 # Utilities
 aiofiles==23.2.1

backend/src/alembic/versions/20251223_003_add_stream_waveform_paths.py

@@ -0,0 +1,37 @@
+"""Add stream_filepath and waveform_filepath
+
+Revision ID: 003
+Revises: 002
+Create Date: 2025-12-23
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '003'
+down_revision: Union[str, None] = '002'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Add stream_filepath and waveform_filepath columns."""
+    # Add stream_filepath column (MP3 128kbps for fast streaming)
+    op.add_column('audio_tracks', sa.Column('stream_filepath', sa.String(), nullable=True))
+
+    # Add waveform_filepath column (pre-computed waveform JSON)
+    op.add_column('audio_tracks', sa.Column('waveform_filepath', sa.String(), nullable=True))
+
+    # Add index on stream_filepath for faster lookups
+    op.create_index('idx_stream_filepath', 'audio_tracks', ['stream_filepath'])
+
+
+def downgrade() -> None:
+    """Remove stream_filepath and waveform_filepath columns."""
+    op.drop_index('idx_stream_filepath', table_name='audio_tracks')
+    op.drop_column('audio_tracks', 'waveform_filepath')
+    op.drop_column('audio_tracks', 'stream_filepath')

backend/src/api/main.py

@@ -1,14 +1,15 @@
 """FastAPI main application."""
-from fastapi import FastAPI
+from fastapi import FastAPI, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from contextlib import asynccontextmanager
 
 from ..utils.config import settings
 from ..utils.logging import setup_logging, get_logger
 from ..models.database import engine, Base
+from ..core.auth import require_auth
 
 # Import routes
-from .routes import tracks, search, audio, analyze, similar, stats
+from .routes import tracks, search, audio, analyze, similar, stats, library, auth
 
 # Setup logging
 setup_logging()
@@ -62,12 +63,18 @@ async def health_check():
 
 
 # Include routers
-app.include_router(tracks.router, prefix="/api/tracks", tags=["tracks"])
+# Auth endpoints (public - no auth required)
-app.include_router(search.router, prefix="/api/search", tags=["search"])
+app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
+
+# Protected endpoints (auth required for ALL routes)
+app.include_router(tracks.router, prefix="/api/tracks", tags=["tracks"], dependencies=[Depends(require_auth)])
+app.include_router(search.router, prefix="/api/search", tags=["search"], dependencies=[Depends(require_auth)])
+# Audio endpoints handle auth internally (support both header and query param)
 app.include_router(audio.router, prefix="/api/audio", tags=["audio"])
-app.include_router(analyze.router, prefix="/api/analyze", tags=["analyze"])
+app.include_router(analyze.router, prefix="/api/analyze", tags=["analyze"], dependencies=[Depends(require_auth)])
-app.include_router(similar.router, prefix="/api", tags=["similar"])
+app.include_router(similar.router, prefix="/api", tags=["similar"], dependencies=[Depends(require_auth)])
-app.include_router(stats.router, prefix="/api/stats", tags=["stats"])
+app.include_router(stats.router, prefix="/api/stats", tags=["stats"], dependencies=[Depends(require_auth)])
+app.include_router(library.router, prefix="/api/library", tags=["library"], dependencies=[Depends(require_auth)])
 
 
 @app.get("/", tags=["root"])

backend/src/api/routes/audio.py

@@ -1,13 +1,15 @@
 """Audio streaming and download endpoints."""
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, Depends, HTTPException, Request, Query, status
 from fastapi.responses import FileResponse
 from sqlalchemy.orm import Session
 from uuid import UUID
 from pathlib import Path
+from typing import Optional
 
 from ...models.database import get_db
 from ...models import crud
 from ...core.waveform_generator import get_waveform_data
+from ...core.auth import verify_token, require_auth
 from ...utils.logging import get_logger
 
 router = APIRouter()
@@ -18,13 +20,18 @@ logger = get_logger(__name__)
 async def stream_audio(
     track_id: UUID,
     request: Request,
+    token: Optional[str] = Query(None),
     db: Session = Depends(get_db),
 ):
     """Stream audio file with range request support.
 
+    Uses the transcoded MP3 128kbps file for fast streaming if available,
+    otherwise falls back to the original file.
+
     Args:
         track_id: Track UUID
         request: HTTP request
+        token: Optional JWT token for authentication (for <audio> tag compatibility)
         db: Database session
 
     Returns:
@@ -33,11 +40,27 @@ async def stream_audio(
     Raises:
         HTTPException: 404 if track not found or file doesn't exist
     """
+    # Verify authentication via query parameter for <audio> tag
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication required",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    verify_token(token)
+
     track = crud.get_track_by_id(db, track_id)
 
     if not track:
         raise HTTPException(status_code=404, detail="Track not found")
 
+    # Prefer stream_filepath (transcoded MP3) if available
+    if track.stream_filepath and Path(track.stream_filepath).exists():
+        file_path = Path(track.stream_filepath)
+        media_type = "audio/mpeg"
+        logger.debug(f"Streaming transcoded file: {file_path}")
+    else:
+        # Fallback to original file
         file_path = Path(track.filepath)
 
         if not file_path.exists():
@@ -53,6 +76,7 @@ async def stream_audio(
             "ogg": "audio/ogg",
         }
         media_type = media_types.get(track.format, "audio/mpeg")
+        logger.debug(f"Streaming original file: {file_path}")
 
     return FileResponse(
         path=str(file_path),
@@ -68,12 +92,14 @@ async def stream_audio(
 @router.get("/download/{track_id}")
 async def download_audio(
     track_id: UUID,
+    token: Optional[str] = Query(None),
     db: Session = Depends(get_db),
 ):
     """Download audio file.
 
     Args:
         track_id: Track UUID
+        token: Optional JWT token for authentication (for <a> tag compatibility)
         db: Database session
 
     Returns:
@@ -82,6 +108,15 @@ async def download_audio(
     Raises:
         HTTPException: 404 if track not found or file doesn't exist
     """
+    # Verify authentication via query parameter for <a> tag
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication required",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    verify_token(token)
+
     track = crud.get_track_by_id(db, track_id)
 
     if not track:
@@ -118,13 +153,17 @@ async def get_waveform(
     track_id: UUID,
     num_peaks: int = 800,
     db: Session = Depends(get_db),
+    current_user: dict = Depends(require_auth),
 ):
     """Get waveform peak data for visualization.
 
+    Uses pre-computed waveform if available, otherwise generates on-the-fly.
+
     Args:
         track_id: Track UUID
         num_peaks: Number of peaks to generate
         db: Database session
+        current_user: Current authenticated user
 
     Returns:
         Waveform data with peaks and duration
@@ -144,7 +183,14 @@ async def get_waveform(
         raise HTTPException(status_code=404, detail="Audio file not found on disk")
 
     try:
-        waveform_data = get_waveform_data(str(file_path), num_peaks=num_peaks)
+        # Use pre-computed waveform if available
+        waveform_cache_path = track.waveform_filepath if track.waveform_filepath else None
+
+        waveform_data = get_waveform_data(
+            str(file_path),
+            num_peaks=num_peaks,
+            waveform_cache_path=waveform_cache_path
+        )
         return waveform_data
 
     except Exception as e:

backend/src/api/routes/auth.py

@@ -0,0 +1,82 @@
+"""Authentication endpoints."""
+from datetime import timedelta
+from fastapi import APIRouter, HTTPException, status, Depends
+from pydantic import BaseModel, EmailStr
+
+from ...core.auth import authenticate_user, create_access_token, get_current_user
+from ...utils.config import settings
+from ...utils.logging import get_logger
+
+router = APIRouter()
+logger = get_logger(__name__)
+
+
+class LoginRequest(BaseModel):
+    """Login request model."""
+    email: EmailStr
+    password: str
+
+
+class LoginResponse(BaseModel):
+    """Login response model."""
+    access_token: str
+    token_type: str = "bearer"
+    user: dict
+
+
+class UserResponse(BaseModel):
+    """User response model."""
+    email: str
+    role: str
+
+
+@router.post("/login", response_model=LoginResponse)
+async def login(request: LoginRequest):
+    """Authenticate user and return JWT token.
+
+    Args:
+        request: Login credentials
+
+    Returns:
+        Access token and user info
+
+    Raises:
+        HTTPException: 401 if credentials are invalid
+    """
+    user = authenticate_user(request.email, request.password)
+
+    if not user:
+        logger.warning(f"Failed login attempt for: {request.email}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    # Create access token
+    access_token_expires = timedelta(hours=settings.JWT_EXPIRATION_HOURS)
+    access_token = create_access_token(
+        data={"sub": user["email"], "role": user["role"]},
+        expires_delta=access_token_expires
+    )
+
+    logger.info(f"User logged in: {user['email']}")
+
+    return {
+        "access_token": access_token,
+        "token_type": "bearer",
+        "user": user
+    }
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_me(current_user: dict = Depends(get_current_user)):
+    """Get current authenticated user info.
+
+    Args:
+        current_user: Current user from JWT token
+
+    Returns:
+        User information
+    """
+    return current_user

backend/src/api/routes/library.py

@@ -0,0 +1,275 @@
+"""Library management endpoints."""
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from sqlalchemy.orm import Session
+from pathlib import Path
+from typing import Optional
+import os
+
+from ...models.database import get_db
+from ...models.schema import AudioTrack
+from ...core.audio_processor import extract_all_features
+from ...core.essentia_classifier import EssentiaClassifier
+from ...core.transcoder import AudioTranscoder
+from ...core.waveform_generator import save_waveform_to_file
+from ...utils.logging import get_logger
+from ...utils.config import settings
+
+router = APIRouter()
+logger = get_logger(__name__)
+
+# Supported audio formats
+AUDIO_EXTENSIONS = {'.mp3', '.wav', '.flac', '.m4a', '.aac', '.ogg', '.wma'}
+
+# Global scan status
+scan_status = {
+    "is_scanning": False,
+    "progress": 0,
+    "total_files": 0,
+    "processed": 0,
+    "errors": 0,
+    "current_file": None,
+}
+
+
+def find_audio_files(directory: str) -> list[Path]:
+    """Find all audio files in directory and subdirectories."""
+    audio_files = []
+    directory_path = Path(directory)
+
+    if not directory_path.exists():
+        logger.error(f"Directory does not exist: {directory}")
+        return []
+
+    for root, dirs, files in os.walk(directory_path):
+        # Skip transcoded and waveforms directories
+        dirs[:] = [d for d in dirs if d not in ['transcoded', 'waveforms', '.transcoded', '.waveforms']]
+
+        for file in files:
+            file_path = Path(root) / file
+            if file_path.suffix.lower() in AUDIO_EXTENSIONS:
+                audio_files.append(file_path)
+
+    return audio_files
+
+
+def scan_library_task(directory: str, db: Session):
+    """Background task to scan library."""
+    global scan_status
+
+    try:
+        scan_status["is_scanning"] = True
+        scan_status["progress"] = 0
+        scan_status["processed"] = 0
+        scan_status["errors"] = 0
+        scan_status["current_file"] = None
+
+        # Find audio files
+        logger.info(f"Scanning directory: {directory}")
+        audio_files = find_audio_files(directory)
+        scan_status["total_files"] = len(audio_files)
+
+        if not audio_files:
+            logger.warning("No audio files found!")
+            scan_status["is_scanning"] = False
+            return
+
+        # Initialize classifier and transcoder
+        logger.info("Initializing Essentia classifier...")
+        classifier = EssentiaClassifier()
+
+        logger.info("Initializing audio transcoder...")
+        transcoder = AudioTranscoder()
+
+        if not transcoder.check_ffmpeg_available():
+            logger.error("FFmpeg is required for transcoding.")
+            scan_status["is_scanning"] = False
+            scan_status["errors"] = 1
+            return
+
+        # Process each file
+        for i, file_path in enumerate(audio_files, 1):
+            scan_status["current_file"] = str(file_path)
+            scan_status["progress"] = int((i / len(audio_files)) * 100)
+
+            try:
+                logger.info(f"[{i}/{len(audio_files)}] Processing: {file_path.name}")
+
+                # Check if already in database
+                existing = db.query(AudioTrack).filter(
+                    AudioTrack.filepath == str(file_path)
+                ).first()
+
+                if existing:
+                    # Check if needs transcoding/waveform
+                    needs_update = False
+
+                    if not existing.stream_filepath or not Path(existing.stream_filepath).exists():
+                        logger.info(f"  → Needs transcoding: {file_path.name}")
+                        needs_update = True
+
+                        # Transcode to MP3 128kbps
+                        stream_path = transcoder.transcode_to_mp3(
+                            str(file_path),
+                            bitrate="128k",
+                            overwrite=False
+                        )
+                        if stream_path:
+                            existing.stream_filepath = stream_path
+
+                    if not existing.waveform_filepath or not Path(existing.waveform_filepath).exists():
+                        logger.info(f"  → Needs waveform: {file_path.name}")
+                        needs_update = True
+
+                        # Pre-compute waveform
+                        waveform_dir = file_path.parent / "waveforms"
+                        waveform_dir.mkdir(parents=True, exist_ok=True)
+                        waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
+
+                        if save_waveform_to_file(str(file_path), str(waveform_path), num_peaks=800):
+                            existing.waveform_filepath = str(waveform_path)
+
+                    if needs_update:
+                        db.commit()
+                        logger.info(f"✓ Updated: {file_path.name}")
+                    else:
+                        logger.info(f"Already complete, skipping: {file_path.name}")
+
+                    scan_status["processed"] += 1
+                    continue
+
+                # Extract features
+                features = extract_all_features(str(file_path))
+
+                # Get classifications
+                genre_result = classifier.predict_genre(str(file_path))
+                mood_result = classifier.predict_mood(str(file_path))
+                instruments = classifier.predict_instruments(str(file_path))
+
+                # Transcode to MP3 128kbps
+                logger.info("  → Transcoding to MP3 128kbps...")
+                stream_path = transcoder.transcode_to_mp3(
+                    str(file_path),
+                    bitrate="128k",
+                    overwrite=False
+                )
+
+                # Pre-compute waveform
+                logger.info("  → Generating waveform...")
+                waveform_dir = file_path.parent / "waveforms"
+                waveform_dir.mkdir(parents=True, exist_ok=True)
+                waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
+
+                waveform_success = save_waveform_to_file(
+                    str(file_path),
+                    str(waveform_path),
+                    num_peaks=800
+                )
+
+                # Create track record
+                track = AudioTrack(
+                    filepath=str(file_path),
+                    stream_filepath=stream_path,
+                    waveform_filepath=str(waveform_path) if waveform_success else None,
+                    filename=file_path.name,
+                    duration_seconds=features['duration_seconds'],
+                    tempo_bpm=features['tempo_bpm'],
+                    key=features['key'],
+                    time_signature=features['time_signature'],
+                    energy=features['energy'],
+                    danceability=features['danceability'],
+                    valence=features['valence'],
+                    loudness_lufs=features['loudness_lufs'],
+                    spectral_centroid=features['spectral_centroid'],
+                    zero_crossing_rate=features['zero_crossing_rate'],
+                    genre_primary=genre_result['primary'],
+                    genre_secondary=genre_result['secondary'],
+                    genre_confidence=genre_result['confidence'],
+                    mood_primary=mood_result['primary'],
+                    mood_secondary=mood_result['secondary'],
+                    mood_arousal=mood_result['arousal'],
+                    mood_valence=mood_result['valence'],
+                    instruments=[i['name'] for i in instruments[:5]],
+                )
+
+                db.add(track)
+                db.commit()
+
+                scan_status["processed"] += 1
+                logger.info(f"✓ Added: {file_path.name}")
+
+            except Exception as e:
+                logger.error(f"Failed to process {file_path}: {e}")
+                scan_status["errors"] += 1
+                db.rollback()
+
+        # Scan complete
+        logger.info("=" * 60)
+        logger.info(f"Scan complete!")
+        logger.info(f"  Total files: {len(audio_files)}")
+        logger.info(f"  Processed: {scan_status['processed']}")
+        logger.info(f"  Errors: {scan_status['errors']}")
+        logger.info("=" * 60)
+
+    except Exception as e:
+        logger.error(f"Scan failed: {e}")
+        scan_status["errors"] += 1
+
+    finally:
+        scan_status["is_scanning"] = False
+        scan_status["current_file"] = None
+
+
+@router.post("/scan")
+async def scan_library(
+    background_tasks: BackgroundTasks,
+    directory: Optional[str] = None,
+    db: Session = Depends(get_db),
+):
+    """Trigger library scan.
+
+    Args:
+        background_tasks: FastAPI background tasks
+        directory: Directory to scan (defaults to MUSIC_DIR from settings)
+        db: Database session
+
+    Returns:
+        Scan status
+
+    Raises:
+        HTTPException: 400 if scan already in progress or directory invalid
+    """
+    global scan_status
+
+    if scan_status["is_scanning"]:
+        raise HTTPException(
+            status_code=400,
+            detail="Scan already in progress"
+        )
+
+    # Use default music directory if not provided
+    scan_dir = directory if directory else "/audio"
+
+    if not Path(scan_dir).exists():
+        raise HTTPException(
+            status_code=400,
+            detail=f"Directory does not exist: {scan_dir}"
+        )
+
+    # Start scan in background
+    background_tasks.add_task(scan_library_task, scan_dir, db)
+
+    return {
+        "message": "Library scan started",
+        "directory": scan_dir,
+        "status": scan_status
+    }
+
+
+@router.get("/scan/status")
+async def get_scan_status():
+    """Get current scan status.
+
+    Returns:
+        Current scan status
+    """
+    return scan_status

backend/src/api/routes/tracks.py

@@ -24,6 +24,7 @@ async def get_tracks(
     has_vocals: Optional[bool] = None,
     key: Optional[str] = None,
     instrument: Optional[str] = None,
+    instruments: Optional[List[str]] = Query(None),
     tempo_range: Optional[str] = Query(None, regex="^(slow|medium|fast)$"),
     sort_by: str = Query("analyzed_at", regex="^(analyzed_at|tempo_bpm|duration_seconds|filename|energy)$"),
     sort_desc: bool = True,
@@ -42,7 +43,8 @@ async def get_tracks(
         energy_max: Maximum energy
         has_vocals: Filter by vocal presence
         key: Filter by musical key
-        instrument: Filter by instrument
+        instrument: Filter by instrument (deprecated, use instruments)
+        instruments: Filter by multiple instruments (must have ALL)
         tempo_range: Filter by tempo range (slow: <100, medium: 100-140, fast: >140)
         sort_by: Field to sort by
         sort_desc: Sort descending
@@ -61,6 +63,9 @@ async def get_tracks(
         elif tempo_range == "fast":
             bpm_min = 140.0 if bpm_min is None else max(bpm_min, 140.0)
 
+    # Use instruments if provided, otherwise fall back to instrument
+    final_instruments = instruments if instruments else ([instrument] if instrument else None)
+
     tracks, total = crud.get_tracks(
         db=db,
         skip=skip,
@@ -73,7 +78,7 @@ async def get_tracks(
         energy_max=energy_max,
         has_vocals=has_vocals,
         key=key,
-        instrument=instrument,
+        instruments=final_instruments,
         sort_by=sort_by,
         sort_desc=sort_desc,
     )

backend/src/cli/scanner.py

@@ -15,6 +15,8 @@ sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
 from src.core.audio_processor import extract_all_features
 from src.core.essentia_classifier import EssentiaClassifier
+from src.core.transcoder import AudioTranscoder
+from src.core.waveform_generator import save_waveform_to_file
 from src.models.database import SessionLocal
 from src.models.schema import AudioTrack
 from src.utils.logging import get_logger
@@ -44,6 +46,9 @@ def find_audio_files(directory: str) -> List[Path]:
     logger.info(f"Scanning directory: {directory}")
 
     for root, dirs, files in os.walk(directory_path):
+        # Skip transcoded and waveforms directories
+        dirs[:] = [d for d in dirs if d not in ['transcoded', 'waveforms', '.transcoded', '.waveforms']]
+
         for file in files:
             file_path = Path(root) / file
             if file_path.suffix.lower() in AUDIO_EXTENSIONS:
@@ -53,12 +58,13 @@ def find_audio_files(directory: str) -> List[Path]:
     return audio_files
 
 
-def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bool:
+def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, transcoder: AudioTranscoder, db) -> bool:
     """Analyze an audio file and store it in the database.
 
     Args:
         file_path: Path to audio file
         classifier: Essentia classifier instance
+        transcoder: Audio transcoder instance
         db: Database session
 
     Returns:
@@ -85,9 +91,31 @@ def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bo
         # Get instruments
         instruments = classifier.predict_instruments(str(file_path))
 
+        # Transcode to MP3 128kbps for streaming
+        logger.info("  → Transcoding to MP3 128kbps for streaming...")
+        stream_path = transcoder.transcode_to_mp3(
+            str(file_path),
+            bitrate="128k",
+            overwrite=False
+        )
+
+        # Pre-compute waveform
+        logger.info("  → Generating waveform...")
+        waveform_dir = file_path.parent / "waveforms"
+        waveform_dir.mkdir(parents=True, exist_ok=True)
+        waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
+
+        waveform_success = save_waveform_to_file(
+            str(file_path),
+            str(waveform_path),
+            num_peaks=800
+        )
+
         # Create track record
         track = AudioTrack(
             filepath=str(file_path),
+            stream_filepath=stream_path,
+            waveform_filepath=str(waveform_path) if waveform_success else None,
             filename=file_path.name,
             duration_seconds=features['duration_seconds'],
             tempo_bpm=features['tempo_bpm'],
@@ -115,6 +143,8 @@ def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bo
         logger.info(f"✓ Added to database: {file_path.name}")
         logger.info(f"  Genre: {genre_result['primary']}, Mood: {mood_result['primary']}, "
                    f"Tempo: {features['tempo_bpm']:.1f} BPM")
+        logger.info(f"  Stream: {stream_path}")
+        logger.info(f"  Waveform: {'✓' if waveform_success else '✗'}")
 
         return True
 
@@ -153,6 +183,15 @@ def main():
     logger.info("Initializing Essentia classifier...")
     classifier = EssentiaClassifier()
 
+    # Initialize transcoder
+    logger.info("Initializing audio transcoder...")
+    transcoder = AudioTranscoder()
+
+    # Check FFmpeg availability
+    if not transcoder.check_ffmpeg_available():
+        logger.error("FFmpeg is required for transcoding. Please install FFmpeg and try again.")
+        return
+
     # Process files
     db = SessionLocal()
     success_count = 0
@@ -162,7 +201,7 @@ def main():
         for i, file_path in enumerate(audio_files, 1):
             logger.info(f"[{i}/{len(audio_files)}] Processing...")
 
-            if analyze_and_store(file_path, classifier, db):
+            if analyze_and_store(file_path, classifier, transcoder, db):
                 success_count += 1
             else:
                 error_count += 1

backend/src/core/auth.py

@@ -0,0 +1,151 @@
+"""Authentication utilities."""
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import HTTPException, status, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from ..utils.config import settings
+from ..utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+# Password hashing
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# HTTP Bearer for JWT
+security = HTTPBearer()
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash.
+
+    Args:
+        plain_password: Plain text password
+        hashed_password: Hashed password
+
+    Returns:
+        True if password matches
+    """
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password.
+
+    Args:
+        password: Plain text password
+
+    Returns:
+        Hashed password
+    """
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create JWT access token.
+
+    Args:
+        data: Data to encode in token
+        expires_delta: Token expiration time
+
+    Returns:
+        JWT token string
+    """
+    to_encode = data.copy()
+
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(hours=settings.JWT_EXPIRATION_HOURS)
+
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.JWT_SECRET_KEY, algorithm="HS256")
+
+    return encoded_jwt
+
+
+def verify_token(token: str) -> dict:
+    """Verify and decode JWT token.
+
+    Args:
+        token: JWT token string
+
+    Returns:
+        Decoded token payload
+
+    Raises:
+        HTTPException: If token is invalid
+    """
+    try:
+        payload = jwt.decode(token, settings.JWT_SECRET_KEY, algorithms=["HS256"])
+        return payload
+    except JWTError as e:
+        logger.error(f"Token verification failed: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Could not validate credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+
+def authenticate_user(email: str, password: str) -> Optional[dict]:
+    """Authenticate user with email and password.
+
+    Args:
+        email: User email
+        password: User password
+
+    Returns:
+        User data if authenticated, None otherwise
+    """
+    # Check against admin credentials from environment
+    if email == settings.ADMIN_EMAIL and password == settings.ADMIN_PASSWORD:
+        return {
+            "email": email,
+            "role": "admin"
+        }
+
+    return None
+
+
+async def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)) -> dict:
+    """Get current authenticated user from JWT token.
+
+    Args:
+        credentials: HTTP Bearer credentials
+
+    Returns:
+        User data from token
+
+    Raises:
+        HTTPException: If authentication fails
+    """
+    token = credentials.credentials
+    payload = verify_token(token)
+
+    email: str = payload.get("sub")
+    if email is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Could not validate credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    return {
+        "email": email,
+        "role": payload.get("role", "user")
+    }
+
+
+async def require_auth(current_user: dict = Depends(get_current_user)) -> dict:
+    """Dependency to require authentication.
+
+    Args:
+        current_user: Current user from get_current_user
+
+    Returns:
+        Current user data
+    """
+    return current_user

backend/src/core/transcoder.py

@@ -0,0 +1,130 @@
+"""Audio transcoding utilities using FFmpeg."""
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from ..utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class AudioTranscoder:
+    """Audio transcoder for creating streaming-optimized files."""
+
+    def __init__(self, output_dir: Optional[str] = None):
+        """Initialize transcoder.
+
+        Args:
+            output_dir: Directory to store transcoded files. If None, uses 'transcoded' subdir next to original.
+        """
+        self.output_dir = output_dir
+
+    def transcode_to_mp3(
+        self,
+        input_path: str,
+        output_path: Optional[str] = None,
+        bitrate: str = "128k",
+        overwrite: bool = False,
+    ) -> Optional[str]:
+        """Transcode audio file to MP3.
+
+        Args:
+            input_path: Path to input audio file
+            output_path: Path to output MP3 file. If None, auto-generated.
+            bitrate: MP3 bitrate (default: 128k for streaming)
+            overwrite: Whether to overwrite existing file
+
+        Returns:
+            Path to transcoded MP3 file, or None if failed
+        """
+        try:
+            input_file = Path(input_path)
+
+            if not input_file.exists():
+                logger.error(f"Input file not found: {input_path}")
+                return None
+
+            # Generate output path if not provided
+            if output_path is None:
+                if self.output_dir:
+                    output_dir = Path(self.output_dir)
+                else:
+                    # Create 'transcoded' directory next to original
+                    output_dir = input_file.parent / "transcoded"
+
+                output_dir.mkdir(parents=True, exist_ok=True)
+                output_path = str(output_dir / f"{input_file.stem}.mp3")
+
+            output_file = Path(output_path)
+
+            # Skip if already exists and not overwriting
+            if output_file.exists() and not overwrite:
+                logger.info(f"Transcoded file already exists: {output_path}")
+                return str(output_file)
+
+            logger.info(f"Transcoding {input_file.name} to MP3 {bitrate}...")
+
+            # FFmpeg command for high-quality MP3 encoding
+            cmd = [
+                "ffmpeg",
+                "-i", str(input_file),
+                "-vn",  # No video
+                "-acodec", "libmp3lame",  # MP3 codec
+                "-b:a", bitrate,  # Bitrate
+                "-q:a", "2",  # High quality VBR (if CBR fails)
+                "-ar", "44100",  # Sample rate
+                "-ac", "2",  # Stereo
+                "-y" if overwrite else "-n",  # Overwrite or not
+                str(output_file),
+            ]
+
+            # Run FFmpeg
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode != 0:
+                logger.error(f"FFmpeg failed: {result.stderr}")
+                return None
+
+            if not output_file.exists():
+                logger.error(f"Transcoding failed: output file not created")
+                return None
+
+            output_size = output_file.stat().st_size
+            input_size = input_file.stat().st_size
+            compression_ratio = (1 - output_size / input_size) * 100
+
+            logger.info(
+                f"✓ Transcoded: {input_file.name} → {output_file.name} "
+                f"({output_size / 1024 / 1024:.2f} MB, {compression_ratio:.1f}% reduction)"
+            )
+
+            return str(output_file)
+
+        except Exception as e:
+            logger.error(f"Failed to transcode {input_path}: {e}")
+            return None
+
+    def check_ffmpeg_available(self) -> bool:
+        """Check if FFmpeg is available.
+
+        Returns:
+            True if FFmpeg is available, False otherwise
+        """
+        try:
+            result = subprocess.run(
+                ["ffmpeg", "-version"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=False,
+            )
+            return result.returncode == 0
+        except FileNotFoundError:
+            logger.error("FFmpeg not found. Please install FFmpeg.")
+            return False

backend/src/core/waveform_generator.py

@@ -87,16 +87,28 @@ def generate_peaks(filepath: str, num_peaks: int = 800, use_cache: bool = True)
         return [0.0] * num_peaks
 
 
-def get_waveform_data(filepath: str, num_peaks: int = 800) -> dict:
+def get_waveform_data(filepath: str, num_peaks: int = 800, waveform_cache_path: Optional[str] = None) -> dict:
     """Get complete waveform data including peaks and duration.
 
     Args:
         filepath: Path to audio file
         num_peaks: Number of peaks
+        waveform_cache_path: Optional path to pre-computed waveform JSON file
 
     Returns:
         Dictionary with peaks and duration
     """
+    # Try to load from provided cache path first
+    if waveform_cache_path and Path(waveform_cache_path).exists():
+        try:
+            with open(waveform_cache_path, 'r') as f:
+                cached_data = json.load(f)
+                if cached_data.get('num_peaks') == num_peaks:
+                    logger.debug(f"Loading peaks from provided cache: {waveform_cache_path}")
+                    return cached_data
+        except Exception as e:
+            logger.warning(f"Failed to load from provided cache path: {e}")
+
     try:
         peaks = generate_peaks(filepath, num_peaks)
 
@@ -117,3 +129,29 @@ def get_waveform_data(filepath: str, num_peaks: int = 800) -> dict:
             'duration': 0.0,
             'num_peaks': num_peaks
         }
+
+
+def save_waveform_to_file(filepath: str, output_path: str, num_peaks: int = 800) -> bool:
+    """Generate and save waveform data to a JSON file.
+
+    Args:
+        filepath: Path to audio file
+        output_path: Path to save waveform JSON
+        num_peaks: Number of peaks to generate
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        waveform_data = get_waveform_data(filepath, num_peaks)
+
+        # Save to file
+        with open(output_path, 'w') as f:
+            json.dump(waveform_data, f)
+
+        logger.info(f"Saved waveform to {output_path}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to save waveform: {e}")
+        return False

backend/src/models/crud.py

@@ -104,7 +104,7 @@ def get_tracks(
     energy_max: Optional[float] = None,
     has_vocals: Optional[bool] = None,
     key: Optional[str] = None,
-    instrument: Optional[str] = None,
+    instruments: Optional[List[str]] = None,
     sort_by: str = "analyzed_at",
     sort_desc: bool = True,
 ) -> Tuple[List[AudioTrack], int]:
@@ -122,7 +122,7 @@ def get_tracks(
         energy_max: Maximum energy (0-1)
         has_vocals: Filter by vocal presence
         key: Filter by musical key
-        instrument: Filter by instrument
+        instruments: Filter by instruments (track must have ALL instruments in the list)
         sort_by: Field to sort by
         sort_desc: Sort descending if True
 
@@ -168,7 +168,9 @@ def get_tracks(
     if key:
         query = query.filter(AudioTrack.key == key)
 
-    if instrument:
+    if instruments:
+        # Track must have ALL specified instruments
+        for instrument in instruments:
             query = query.filter(AudioTrack.instruments.any(instrument))
 
     # Get total count before pagination

backend/src/models/schema.py

@@ -19,7 +19,9 @@ class AudioTrack(Base):
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid4, server_default=text("gen_random_uuid()"))
 
     # File information
-    filepath = Column(String, unique=True, nullable=False, index=True)
+    filepath = Column(String, unique=True, nullable=False, index=True)  # Original file (for download)
+    stream_filepath = Column(String, nullable=True, index=True)  # MP3 128kbps (for streaming preview)
+    waveform_filepath = Column(String, nullable=True)  # Pre-computed waveform JSON
     filename = Column(String, nullable=False)
     duration_seconds = Column(Float, nullable=True)
     file_size_bytes = Column(BigInteger, nullable=True)
@@ -84,6 +86,8 @@ class AudioTrack(Base):
         return {
             "id": str(self.id),
             "filepath": self.filepath,
+            "stream_filepath": self.stream_filepath,
+            "waveform_filepath": self.waveform_filepath,
             "filename": self.filename,
             "duration_seconds": self.duration_seconds,
             "file_size_bytes": self.file_size_bytes,

backend/src/utils/config.py

@@ -10,7 +10,8 @@ class Settings(BaseSettings):
     DATABASE_URL: str = "postgresql://audio_user:audio_password@localhost:5432/audio_classifier"
 
     # API Configuration
-    CORS_ORIGINS: str = "http://localhost:3000,http://127.0.0.1:3000"
+    # Comma-separated list of allowed origins, or use "*" to allow all
+    CORS_ORIGINS: str = "*"
     API_HOST: str = "0.0.0.0"
     API_PORT: int = 8000
 
@@ -20,6 +21,12 @@ class Settings(BaseSettings):
     ESSENTIA_MODELS_PATH: str = "./models"
     AUDIO_LIBRARY_PATH: str = "/audio"
 
+    # Authentication
+    ADMIN_EMAIL: str = "admin@example.com"
+    ADMIN_PASSWORD: str = "changeme"
+    JWT_SECRET_KEY: str = "your-secret-key-change-in-production"
+    JWT_EXPIRATION_HOURS: int = 24
+
     # Application
     APP_NAME: str = "Audio Classifier API"
     APP_VERSION: str = "1.0.0"
@@ -33,7 +40,13 @@ class Settings(BaseSettings):
 
     @property
     def cors_origins_list(self) -> List[str]:
-        """Parse CORS origins string to list."""
+        """Parse CORS origins string to list.
+
+        If CORS_ORIGINS is "*", allow all origins.
+        Otherwise, parse comma-separated list.
+        """
+        if self.CORS_ORIGINS.strip() == "*":
+            return ["*"]
         return [origin.strip() for origin in self.CORS_ORIGINS.split(",")]
 
 

check-autonomous.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Script de vérification autonomie
+
+echo "=== Vérification Audio Classifier Autonome ==="
+echo ""
+
+# Check 1: Docker Compose
+echo "✓ Checking docker-compose.yml..."
+if [ ! -f "docker-compose.yml" ]; then
+    echo "  ❌ docker-compose.yml missing"
+    exit 1
+fi
+echo "  ✓ docker-compose.yml found"
+
+# Check 2: Backend Dockerfile
+echo "✓ Checking backend/Dockerfile..."
+if ! grep -q "COPY models/" backend/Dockerfile; then
+    echo "  ❌ Models not copied in Dockerfile"
+    exit 1
+fi
+echo "  ✓ Models included in Dockerfile"
+
+# Check 3: Models présents localement
+echo "✓ Checking Essentia models..."
+MODEL_COUNT=$(ls backend/models/*.pb 2>/dev/null | wc -l)
+if [ "$MODEL_COUNT" -lt 4 ]; then
+    echo "  ❌ Missing models in backend/models/ ($MODEL_COUNT found, need 4+)"
+    exit 1
+fi
+echo "  ✓ $MODEL_COUNT model files found"
+
+# Check 4: No volume mount for models
+echo "✓ Checking no models volume mount..."
+if grep -q "./backend/models:/app/models" docker-compose.yml; then
+    echo "  ❌ Models volume mount still present in docker-compose.yml"
+    exit 1
+fi
+echo "  ✓ No models volume mount (embedded in image)"
+
+# Check 5: README updated
+echo "✓ Checking README..."
+if ! grep -q "100% Autonome" README.md; then
+    echo "  ⚠️  README might need update"
+else
+    echo "  ✓ README mentions autonomous setup"
+fi
+
+echo ""
+echo "=== ✓ All checks passed! ==="
+echo ""
+echo "Your Docker setup is fully autonomous:"
+echo "  - Models included in image (28 MB)"
+echo "  - No manual downloads required"
+echo "  - Ready for deployment anywhere"
+echo ""
+echo "To deploy:"
+echo "  docker-compose up -d"
+echo ""

docker-compose.build.yml

@@ -1,4 +1,5 @@
-version: '3.8'
+# Docker Compose pour build local (développement)
+# Usage: docker-compose -f docker-compose.build.yml build
 
 services:
   postgres:
@@ -20,43 +21,40 @@ services:
       retries: 5
     restart: unless-stopped
 
-  # Backend with minimal dependencies (no Essentia)
   backend:
     build:
-      context: ./backend
+      context: .
-      dockerfile: Dockerfile.minimal
+      dockerfile: backend/Dockerfile
     container_name: audio_classifier_api
     depends_on:
       postgres:
         condition: service_healthy
     environment:
       DATABASE_URL: postgresql://${POSTGRES_USER:-audio_user}:${POSTGRES_PASSWORD:-audio_password}@postgres:5432/${POSTGRES_DB:-audio_classifier}
-      CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3000}
+      CORS_ORIGINS: ${CORS_ORIGINS:-*}
-      ANALYSIS_USE_CLAP: "false"
+      ANALYSIS_USE_CLAP: ${ANALYSIS_USE_CLAP:-false}
       ANALYSIS_NUM_WORKERS: ${ANALYSIS_NUM_WORKERS:-4}
       ESSENTIA_MODELS_PATH: /app/models
     ports:
       - "8001:8000"
     volumes:
-      # Mount your audio library (read-only)
+      # Mount your audio library (read-write for transcoding and waveforms)
-      - ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio:ro
+      - ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio
-      # Development: mount source for hot reload
-      - ./backend/src:/app/src
     restart: unless-stopped
 
   frontend:
     build:
-      context: ./frontend
+      context: .
-      dockerfile: Dockerfile.dev
+      dockerfile: frontend/Dockerfile
-    container_name: audio_classifier_ui_dev
+      args:
+        NEXT_PUBLIC_API_URL: http://localhost:8001
+    container_name: audio_classifier_ui
     environment:
-      NEXT_PUBLIC_API_URL: http://backend:8000
+      # Use localhost:8001 because the browser (client-side) needs to access the API
-      NODE_ENV: development
+      # The backend is mapped to port 8001 on the host machine
+      NEXT_PUBLIC_API_URL: http://localhost:8001
     ports:
       - "3000:3000"
-    volumes:
-      - ./frontend:/app
-      - /app/node_modules
     depends_on:
       - backend
     restart: unless-stopped

docker-compose.yml

@@ -19,36 +19,34 @@ services:
     restart: unless-stopped
 
   backend:
-    build: ./backend
+    image: git.benoitsz.com/benoit/audio-classifier-backend:dev
     container_name: audio_classifier_api
     depends_on:
       postgres:
         condition: service_healthy
     environment:
       DATABASE_URL: postgresql://${POSTGRES_USER:-audio_user}:${POSTGRES_PASSWORD:-audio_password}@postgres:5432/${POSTGRES_DB:-audio_classifier}
-      CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3000}
+      CORS_ORIGINS: ${CORS_ORIGINS:-*}
       ANALYSIS_USE_CLAP: ${ANALYSIS_USE_CLAP:-false}
       ANALYSIS_NUM_WORKERS: ${ANALYSIS_NUM_WORKERS:-4}
       ESSENTIA_MODELS_PATH: /app/models
+      # Authentication
+      ADMIN_EMAIL: ${ADMIN_EMAIL:-admin@example.com}
+      ADMIN_PASSWORD: ${ADMIN_PASSWORD:-changeme}
+      JWT_SECRET_KEY: ${JWT_SECRET_KEY:-your-secret-key-change-in-production}
+      JWT_EXPIRATION_HOURS: ${JWT_EXPIRATION_HOURS:-24}
     ports:
       - "8001:8000"
     volumes:
-      # Mount your audio library (read-only)
+      # Mount your audio library (read-write for transcoding and waveforms)
-      - ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio:ro
+      - ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio
-      # Mount models directory
-      - ./backend/models:/app/models
     restart: unless-stopped
 
   frontend:
-    build:
+    image: git.benoitsz.com/benoit/audio-classifier-frontend:dev
-      context: ./frontend
-      args:
-        NEXT_PUBLIC_API_URL: http://localhost:8001
     container_name: audio_classifier_ui
     environment:
-      # Use localhost:8001 because the browser (client-side) needs to access the API
+      NEXT_PUBLIC_API_URL: https://api.audioclassifier.benoitsz.com
-      # The backend is mapped to port 8001 on the host machine
-      NEXT_PUBLIC_API_URL: http://localhost:8001
     ports:
       - "3000:3000"
     depends_on:

frontend/.env.local.example

@@ -1 +1 @@
-NEXT_PUBLIC_API_URL=http://localhost:8000
+NEXT_PUBLIC_API_URL=http://localhost:8001

frontend/Dockerfile

@@ -4,23 +4,27 @@ FROM node:20-alpine
 WORKDIR /app
 
 # Copy package files
-COPY package*.json ./
+COPY frontend/package*.json ./
 
 # Install dependencies
 RUN npm ci
 
 # Copy application code
-COPY . .
+COPY frontend/ .
 
-# Build argument for API URL
+# Build argument for API URL (used for default build)
 ARG NEXT_PUBLIC_API_URL=http://localhost:8001
 ENV NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL}
 
 # Build the application
 RUN npm run build
 
+# Copy runtime config generation script
+COPY frontend/generate-config.sh /app/generate-config.sh
+RUN chmod +x /app/generate-config.sh
+
 # Expose port
 EXPOSE 3000
 
-# Start the application
+# Generate runtime config and start the application
-CMD ["npm", "start"]
+CMD ["/bin/sh", "-c", "/app/generate-config.sh && npm start"]

frontend/Dockerfile.dev

@@ -6,8 +6,11 @@ WORKDIR /app
 # Copy package files
 COPY package*.json ./
 
-# Install dependencies
+# Debug: List files and Node.js version
-RUN npm ci
+RUN ls -la && node --version && npm --version
+
+# Install dependencies with more verbose output
+RUN npm install --verbose
 
 # Expose port
 EXPOSE 3000

frontend/README.md

@@ -0,0 +1,93 @@
+# Frontend - Audio Classifier
+
+Frontend Next.js pour Audio Classifier avec configuration runtime.
+
+## Configuration Runtime
+
+Le frontend utilise un système de **configuration runtime** qui permet de changer l'URL de l'API sans rebuilder l'image Docker.
+
+### Comment ça fonctionne
+
+1. Au démarrage du container, le script `generate-config.sh` génère un fichier `/app/public/config.js`
+2. Ce fichier contient l'URL de l'API basée sur la variable `NEXT_PUBLIC_API_URL`
+3. Le fichier est chargé dans le navigateur via `<Script src="/config.js">`
+4. Le code API lit la configuration depuis `window.__RUNTIME_CONFIG__.API_URL`
+
+### Développement Local
+
+```bash
+# Installer les dépendances
+npm install
+
+# Créer un fichier .env.local
+echo "NEXT_PUBLIC_API_URL=http://localhost:8001" > .env.local
+
+# Lancer en mode dev
+npm run dev
+```
+
+### Production avec Docker
+
+```bash
+# Build l'image
+docker build -t audio-classifier-frontend -f frontend/Dockerfile .
+
+# Lancer avec une URL personnalisée
+docker run -p 3000:3000 \
+  -e NEXT_PUBLIC_API_URL=https://mon-serveur.com:8001 \
+  audio-classifier-frontend
+```
+
+### Docker Compose
+
+```yaml
+frontend:
+  image: audio-classifier-frontend
+  environment:
+    NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL:-http://localhost:8001}
+  ports:
+    - "3000:3000"
+```
+
+## Structure
+
+```
+frontend/
+├── app/                    # Pages Next.js (App Router)
+│   ├── layout.tsx         # Layout principal (charge config.js)
+│   └── page.tsx           # Page d'accueil
+├── components/            # Composants React
+├── lib/                   # Utilitaires
+│   ├── api.ts            # Client API (lit la config runtime)
+│   └── types.ts          # Types TypeScript
+├── public/               # Fichiers statiques
+│   └── config.js         # Configuration runtime (généré au démarrage)
+├── generate-config.sh    # Script de génération de config
+└── Dockerfile            # Image Docker de production
+```
+
+## Variables d'Environnement
+
+- `NEXT_PUBLIC_API_URL` : URL de l'API backend (ex: `https://api.example.com:8001`)
+
+## Troubleshooting
+
+### L'API n'est pas accessible
+
+Vérifiez que :
+1. La variable `NEXT_PUBLIC_API_URL` est correctement définie
+2. Le fichier `/app/public/config.js` existe dans le container
+3. Le navigateur peut accéder à l'URL de l'API (pas de CORS, firewall, etc.)
+
+### Voir la configuration active
+
+Ouvrez la console du navigateur et tapez :
+```javascript
+console.log(window.__RUNTIME_CONFIG__)
+```
+
+### Vérifier la config dans le container
+
+```bash
+docker exec audio_classifier_ui cat /app/public/config.js
+```

frontend/app/layout.tsx

@@ -2,6 +2,8 @@ import type { Metadata } from "next"
 import { Inter } from "next/font/google"
 import "./globals.css"
 import { QueryProvider } from "@/components/providers/QueryProvider"
+import AuthGuard from "@/components/AuthGuard"
+import Script from "next/script"
 
 const inter = Inter({ subsets: ["latin"] })
 
@@ -17,9 +19,14 @@ export default function RootLayout({
 }) {
   return (
     <html lang="en">
+      <head>
+        <Script src="/config.js" strategy="beforeInteractive" />
+      </head>
       <body className={inter.className}>
         <QueryProvider>
+          <AuthGuard>
             {children}
+          </AuthGuard>
         </QueryProvider>
       </body>
     </html>

frontend/app/login/page.tsx

@@ -0,0 +1,124 @@
+"use client"
+
+import { useState } from "react"
+import { useRouter } from "next/navigation"
+import { getApiUrl } from "@/lib/api"
+
+export default function LoginPage() {
+  const router = useRouter()
+  const [email, setEmail] = useState("")
+  const [password, setPassword] = useState("")
+  const [error, setError] = useState("")
+  const [isLoading, setIsLoading] = useState(false)
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setError("")
+    setIsLoading(true)
+
+    try {
+      const response = await fetch(`${getApiUrl()}/api/auth/login`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ email, password }),
+      })
+
+      if (!response.ok) {
+        const data = await response.json()
+        throw new Error(data.detail || "Login failed")
+      }
+
+      const data = await response.json()
+
+      // Store token in localStorage
+      localStorage.setItem("access_token", data.access_token)
+      localStorage.setItem("user", JSON.stringify(data.user))
+
+      // Redirect to home
+      router.push("/")
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Login failed")
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-gradient-to-br from-gray-900 via-gray-800 to-gray-900">
+      <div className="max-w-md w-full mx-4">
+        <div className="bg-white rounded-lg shadow-2xl p-8">
+          {/* Logo/Title */}
+          <div className="text-center mb-8">
+            <h1 className="text-3xl font-bold text-gray-900 mb-2">
+              Audio Classifier
+            </h1>
+            <p className="text-gray-600">Sign in to continue</p>
+          </div>
+
+          {/* Error message */}
+          {error && (
+            <div className="mb-4 p-3 bg-red-50 border border-red-200 text-red-700 rounded-md text-sm">
+              {error}
+            </div>
+          )}
+
+          {/* Login form */}
+          <form onSubmit={handleSubmit} className="space-y-6">
+            <div>
+              <label
+                htmlFor="email"
+                className="block text-sm font-medium text-gray-700 mb-1"
+              >
+                Email
+              </label>
+              <input
+                id="email"
+                type="email"
+                required
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+                className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                placeholder="admin@example.com"
+                disabled={isLoading}
+              />
+            </div>
+
+            <div>
+              <label
+                htmlFor="password"
+                className="block text-sm font-medium text-gray-700 mb-1"
+              >
+                Password
+              </label>
+              <input
+                id="password"
+                type="password"
+                required
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+                className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                placeholder="••••••••"
+                disabled={isLoading}
+              />
+            </div>
+
+            <button
+              type="submit"
+              disabled={isLoading}
+              className="w-full bg-blue-600 hover:bg-blue-700 text-white font-medium py-2 px-4 rounded-md transition-colors disabled:bg-blue-400 disabled:cursor-not-allowed"
+            >
+              {isLoading ? "Signing in..." : "Sign in"}
+            </button>
+          </form>
+        </div>
+
+        {/* Footer */}
+        <p className="text-center text-gray-400 text-sm mt-6">
+          Audio Classifier v1.0.0
+        </p>
+      </div>
+    </div>
+  )
+}

frontend/app/page.tsx

@@ -2,12 +2,13 @@
 
 import { useState, useMemo } from "react"
 import { useQuery } from "@tanstack/react-query"
-import { getTracks, getStats } from "@/lib/api"
+import { getTracks, getApiUrl } from "@/lib/api"
+import { logout, getUser } from "@/lib/auth"
 import type { FilterParams, Track } from "@/lib/types"
 import FilterPanel from "@/components/FilterPanel"
 import AudioPlayer from "@/components/AudioPlayer"
 
-// Helper function to format Discogs genre labels (e.g., "Pop---Ballad" -> ["Pop", "Ballad"])
+// Helper function to format Discogs genre labels
 function formatGenre(genre: string): { category: string; subgenre: string } {
   const parts = genre.split('---')
   return {
@@ -24,21 +25,17 @@ function extractFilterOptions(tracks: Track[]) {
   const keys = new Set<string>()
 
   tracks.forEach(track => {
-    // Extract genre category (before "---")
     const genreCategory = formatGenre(track.classification.genre.primary).category
     genres.add(genreCategory)
 
-    // Extract primary mood
     if (track.classification.mood.primary) {
       moods.add(track.classification.mood.primary)
     }
 
-    // Extract instruments
     track.classification.instruments?.forEach(instrument => {
       instruments.add(instrument)
     })
 
-    // Extract key
     if (track.features.key) {
       keys.add(track.features.key)
     }
@@ -56,21 +53,30 @@ export default function Home() {
   const [filters, setFilters] = useState<FilterParams>({})
   const [page, setPage] = useState(0)
   const [currentTrack, setCurrentTrack] = useState<Track | null>(null)
-  const limit = 50
+  const [isPlaying, setIsPlaying] = useState(false)
+  const [searchQuery, setSearchQuery] = useState("")
+  const [isScanning, setIsScanning] = useState(false)
+  const [scanStatus, setScanStatus] = useState<string>("")
+  const limit = 25
 
   const { data: tracksData, isLoading: isLoadingTracks } = useQuery({
     queryKey: ['tracks', filters, page],
     queryFn: () => getTracks({ ...filters, skip: page * limit, limit }),
   })
 
-  const { data: stats } = useQuery({
+  // Filter tracks by search query on client side
-    queryKey: ['stats'],
+  const filteredTracks = useMemo(() => {
-    queryFn: getStats,
+    if (!tracksData?.tracks) return []
-  })
+    if (!searchQuery.trim()) return tracksData.tracks
+
+    const query = searchQuery.toLowerCase()
+    return tracksData.tracks.filter(track =>
+      track.filename.toLowerCase().includes(query) ||
+      track.metadata?.title?.toLowerCase().includes(query) ||
+      track.metadata?.artist?.toLowerCase().includes(query)
+    )
+  }, [tracksData?.tracks, searchQuery])
 
-  // Extract filter options from displayed tracks
-  // For better UX, we use the current page's tracks to populate filters
-  // TODO: Add a dedicated API endpoint to get all unique filter values
   const filterOptions = useMemo(() => {
     if (!tracksData?.tracks || tracksData.tracks.length === 0) {
       return { genres: [], moods: [], instruments: [], keys: [] }
@@ -78,214 +84,314 @@ export default function Home() {
     return extractFilterOptions(tracksData.tracks)
   }, [tracksData])
 
+  const totalPages = tracksData ? Math.ceil(tracksData.total / limit) : 0
+
+  const handleRescan = async () => {
+    try {
+      setIsScanning(true)
+      setScanStatus("Démarrage du scan...")
+
+      const token = localStorage.getItem('access_token')
+      const headers: HeadersInit = {
+        'Content-Type': 'application/json',
+      }
+      if (token) {
+        headers['Authorization'] = `Bearer ${token}`
+      }
+
+      const response = await fetch(`${getApiUrl()}/api/library/scan`, {
+        method: 'POST',
+        headers,
+      })
+
+      if (!response.ok) {
+        throw new Error('Échec du démarrage du scan')
+      }
+
+      setScanStatus("Scan en cours...")
+
+      // Poll scan status
+      const pollInterval = setInterval(async () => {
+        try {
+          const token = localStorage.getItem('access_token')
+          const pollHeaders: HeadersInit = {}
+          if (token) {
+            pollHeaders['Authorization'] = `Bearer ${token}`
+          }
+
+          const statusResponse = await fetch(`${getApiUrl()}/api/library/scan/status`, {
+            headers: pollHeaders,
+          })
+          const status = await statusResponse.json()
+
+          if (!status.is_scanning) {
+            clearInterval(pollInterval)
+            setScanStatus(`Scan terminé ! ${status.processed} fichiers traités`)
+            setIsScanning(false)
+
+            // Refresh tracks after scan
+            window.location.reload()
+          } else {
+            setScanStatus(`Scan : ${status.processed}/${status.total_files} fichiers (${status.progress}%)`)
+          }
+        } catch (error) {
+          console.error('Erreur lors de la vérification du statut:', error)
+        }
+      }, 2000)
+
+    } catch (error) {
+      console.error('Erreur lors du rescan:', error)
+      setScanStatus("Erreur lors du scan")
+      setIsScanning(false)
+    }
+  }
+
   return (
-    <div className="min-h-screen bg-gray-50">
+    <div className="min-h-screen bg-gradient-to-br from-slate-50 to-slate-100 flex flex-col">
       {/* Header */}
-      <header className="bg-white border-b">
+      <header className="bg-white border-b border-slate-200 shadow-sm sticky top-0 z-40">
-        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-4">
+        <div className="px-6 py-4">
-          <h1 className="text-3xl font-bold text-gray-900">Audio Classifier</h1>
+          <div className="flex items-center justify-between">
-          <p className="text-gray-600">Intelligent music library management</p>
+            <div>
+              <h1 className="text-2xl font-bold text-slate-800">Bibliothèque Musicale</h1>
+              <p className="text-sm text-slate-600">Gestion intelligente de votre collection audio</p>
+            </div>
+
+            {/* Search bar */}
+            <div className="flex-1 max-w-md ml-8">
+              <div className="relative">
+                <input
+                  type="text"
+                  placeholder="Rechercher un titre, artiste..."
+                  value={searchQuery}
+                  onChange={(e) => setSearchQuery(e.target.value)}
+                  className="w-full px-4 py-2 pl-10 bg-slate-50 border border-slate-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-transparent text-sm"
+                />
+                <svg className="absolute left-3 top-2.5 w-5 h-5 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" />
+                </svg>
+              </div>
+            </div>
+
+            <div className="ml-6 flex items-center gap-3">
+              <div className="text-sm text-slate-600">
+                {tracksData?.total || 0} piste{(tracksData?.total || 0) > 1 ? 's' : ''}
+              </div>
+
+              {/* Logout button */}
+              <button
+                onClick={logout}
+                className="px-3 py-2 text-sm text-slate-600 hover:text-slate-900 hover:bg-slate-100 rounded-lg transition-colors flex items-center gap-2"
+                title="Déconnexion"
+              >
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1" />
+                </svg>
+                Logout
+              </button>
+
+              {/* Rescan button */}
+              <button
+                onClick={handleRescan}
+                disabled={isScanning}
+                className="px-4 py-2 bg-orange-500 hover:bg-orange-600 disabled:bg-slate-300 disabled:cursor-not-allowed text-white text-sm font-medium rounded-lg transition-colors flex items-center gap-2"
+                title="Rescanner la bibliothèque musicale"
+              >
+                <svg className={`w-4 h-4 ${isScanning ? 'animate-spin' : ''}`} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                </svg>
+                {isScanning ? 'Scan en cours...' : 'Rescan'}
+              </button>
+
+              {/* Scan status */}
+              {scanStatus && (
+                <div className="text-xs text-slate-600 bg-slate-100 px-3 py-1 rounded">
+                  {scanStatus}
+                </div>
+              )}
+            </div>
+          </div>
         </div>
       </header>
 
-      {/* Main Content */}
+      {/* Main content with sidebar */}
-      <main className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8 pb-32">
+      <div className="flex-1 flex overflow-hidden">
-        {/* Stats */}
+        {/* Sidebar */}
-        {stats && (
+        <aside className="w-72 bg-white border-r border-slate-200 overflow-y-auto">
-          <div className="grid grid-cols-1 md:grid-cols-4 gap-4 mb-8">
+          <div className="p-6">
-            <div className="bg-white p-4 rounded-lg shadow">
+            <h2 className="text-lg font-semibold text-slate-800 mb-4">Filtres</h2>
-              <p className="text-gray-600 text-sm">Total Tracks</p>
-              <p className="text-2xl font-bold">{stats.total_tracks}</p>
-            </div>
-            <div className="bg-white p-4 rounded-lg shadow">
-              <p className="text-gray-600 text-sm">Avg BPM</p>
-              <p className="text-2xl font-bold">{stats.average_bpm}</p>
-            </div>
-            <div className="bg-white p-4 rounded-lg shadow">
-              <p className="text-gray-600 text-sm">Total Hours</p>
-              <p className="text-2xl font-bold">{stats.total_duration_hours}h</p>
-            </div>
-            <div className="bg-white p-4 rounded-lg shadow">
-              <p className="text-gray-600 text-sm">Genres</p>
-              <p className="text-2xl font-bold">{stats.genres.length}</p>
-            </div>
-          </div>
-        )}
-
-        {/* Filter Panel */}
             <FilterPanel
               filters={filters}
               onFiltersChange={(newFilters) => {
                 setFilters(newFilters)
-            setPage(0) // Reset to first page when filters change
+                setPage(0)
               }}
               availableGenres={filterOptions.genres}
               availableMoods={filterOptions.moods}
               availableInstruments={filterOptions.instruments}
               availableKeys={filterOptions.keys}
             />
-
-        {/* Tracks List */}
-        <div className="bg-white rounded-lg shadow">
-          <div className="p-4 border-b">
-            <h2 className="text-xl font-semibold">Music Library</h2>
-            <p className="text-gray-600 text-sm">
-              {tracksData?.total || 0} tracks total
-            </p>
           </div>
+        </aside>
 
+        {/* Tracks list */}
+        <main className="flex-1 overflow-y-auto pb-32">
+          <div className="p-6">
             {isLoadingTracks ? (
-            <div className="p-8 text-center text-gray-600">Loading...</div>
+              <div className="flex items-center justify-center h-64">
-          ) : tracksData?.tracks.length === 0 ? (
+                <div className="text-slate-600">Chargement...</div>
-            <div className="p-8 text-center text-gray-600">
+              </div>
-              No tracks found. Start by analyzing your audio library!
+            ) : filteredTracks.length === 0 ? (
+              <div className="flex flex-col items-center justify-center h-64 text-slate-500">
+                <svg className="w-16 h-16 mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 19V6l12-3v13M9 19c0 1.105-1.343 2-3 2s-3-.895-3-2 1.343-2 3-2 3 .895 3 2zm12-3c0 1.105-1.343 2-3 2s-3-.895-3-2 1.343-2 3-2 3 .895 3 2zM9 10l12-3" />
+                </svg>
+                <p className="text-lg font-medium">Aucune piste trouvée</p>
+                <p className="text-sm mt-2">Essayez de modifier vos filtres ou votre recherche</p>
               </div>
             ) : (
-            <div className="divide-y">
+              <>
-              {tracksData?.tracks.map((track) => (
+                <div className="grid grid-cols-1 gap-3">
-                <div key={track.id} className="p-4 hover:bg-gray-50">
+                  {filteredTracks.map((track) => (
-                  <div className="flex justify-between items-start">
+                    <div
-                    <div className="flex-1">
+                      key={track.id}
-                      <h3 className="font-medium text-gray-900">{track.filename}</h3>
+                      className={`bg-white rounded-lg p-4 border transition-all hover:shadow-md ${
+                        currentTrack?.id === track.id
+                          ? 'border-orange-500 shadow-md'
+                          : 'border-slate-200 hover:border-slate-300'
+                      }`}
+                    >
+                      <div className="flex items-center gap-4">
+                        {/* Play button */}
+                        <button
+                          onClick={() => {
+                            if (currentTrack?.id === track.id) {
+                              // Toggle play/pause for current track
+                              setIsPlaying(!isPlaying)
+                            } else {
+                              // Switch to new track and start playing
+                              setCurrentTrack(track)
+                              setIsPlaying(true)
+                            }
+                          }}
+                          className="flex-shrink-0 w-12 h-12 flex items-center justify-center bg-orange-500 hover:bg-orange-600 rounded-full transition-colors shadow-sm"
+                        >
+                          {currentTrack?.id === track.id && isPlaying ? (
+                            <svg className="w-5 h-5 text-white" fill="currentColor" viewBox="0 0 24 24">
+                              <path d="M6 4h4v16H6V4zm8 0h4v16h-4V4z"/>
+                            </svg>
+                          ) : (
+                            <svg className="w-5 h-5 text-white ml-0.5" fill="currentColor" viewBox="0 0 24 24">
+                              <path d="M8 5v14l11-7z"/>
+                            </svg>
+                          )}
+                        </button>
 
-                      {/* Primary metadata */}
+                        {/* Track info */}
-                      <div className="mt-1 flex flex-wrap gap-2">
+                        <div className="flex-1 min-w-0">
+                          <h3 className="font-semibold text-slate-800 truncate text-base">
+                            {track.metadata?.title || track.filename}
+                          </h3>
+                          {track.metadata?.artist && (
+                            <p className="text-sm text-slate-600 truncate">{track.metadata.artist}</p>
+                          )}
+
+                          <div className="flex flex-wrap gap-2 mt-2">
+                            {/* Genre */}
                             {(() => {
                               const genre = formatGenre(track.classification.genre.primary)
                               return (
                                 <>
-                              <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-blue-100 text-blue-800 font-semibold">
+                                  <span className="inline-flex items-center px-2.5 py-0.5 rounded-md text-xs font-medium bg-orange-100 text-orange-800">
                                     {genre.category}
                                   </span>
                                   {genre.subgenre && (
-                                <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-blue-50 text-blue-700">
+                                    <span className="inline-flex items-center px-2.5 py-0.5 rounded-md text-xs font-medium bg-orange-50 text-orange-700">
                                       {genre.subgenre}
                                     </span>
                                   )}
                                 </>
                               )
                             })()}
-                        <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-purple-100 text-purple-800">
+
+                            {/* Mood */}
+                            <span className="inline-flex items-center px-2.5 py-0.5 rounded-md text-xs font-medium bg-purple-100 text-purple-800">
                               {track.classification.mood.primary}
                             </span>
-                        <span className="text-xs text-gray-500">
+
-                          {Math.round(track.features.tempo_bpm)} BPM
+                            {/* Key & BPM */}
-                        </span>
+                            <span className="inline-flex items-center px-2.5 py-0.5 rounded-md text-xs font-medium bg-slate-100 text-slate-700">
-                        <span className="text-xs text-gray-500">
                               {track.features.key}
                             </span>
-                        <span className="text-xs text-gray-500">
+                            <span className="inline-flex items-center px-2.5 py-0.5 rounded-md text-xs font-medium bg-slate-100 text-slate-700">
+                              {Math.round(track.features.tempo_bpm)} BPM
+                            </span>
+
+                            {/* Duration */}
+                            <span className="inline-flex items-center px-2.5 py-0.5 rounded-md text-xs font-medium bg-slate-100 text-slate-700">
                               {Math.floor(track.duration_seconds / 60)}:{String(Math.floor(track.duration_seconds % 60)).padStart(2, '0')}
                             </span>
                           </div>
 
-                      {/* Secondary genres */}
-                      {track.classification.genre.secondary && track.classification.genre.secondary.length > 0 && (
-                        <div className="mt-2 flex flex-wrap gap-1">
-                          <span className="text-xs text-gray-400">Also:</span>
-                          {track.classification.genre.secondary.slice(0, 3).map((g, i) => {
-                            const genre = formatGenre(g)
-                            return (
-                              <span key={i} className="inline-flex items-center px-2 py-0.5 rounded text-xs bg-blue-50 text-blue-600">
-                                {genre.category}{genre.subgenre && ` • ${genre.subgenre}`}
-                              </span>
-                            )
-                          })}
-                        </div>
-                      )}
-
-                      {/* Secondary moods */}
-                      {track.classification.mood.secondary && track.classification.mood.secondary.length > 0 && (
-                        <div className="mt-2 flex flex-wrap gap-1">
-                          <span className="text-xs text-gray-400">Moods:</span>
-                          {track.classification.mood.secondary.map((mood, i) => (
-                            <span key={i} className="inline-flex items-center px-2 py-0.5 rounded text-xs bg-purple-50 text-purple-600">
-                              {mood}
-                            </span>
-                          ))}
-                        </div>
-                      )}
-
                           {/* Instruments */}
                           {track.classification.instruments && track.classification.instruments.length > 0 && (
-                        <div className="mt-2 flex flex-wrap gap-1">
+                            <div className="flex flex-wrap gap-1.5 mt-2">
-                          <span className="text-xs text-gray-400">Instruments:</span>
+                              <span className="text-xs text-slate-500">Instruments:</span>
-                          {track.classification.instruments.slice(0, 6).map((instrument, i) => (
+                              {track.classification.instruments.slice(0, 5).map((instrument, i) => (
-                            <span key={i} className="inline-flex items-center px-2 py-0.5 rounded text-xs bg-green-50 text-green-700">
+                                <span key={i} className="inline-flex items-center px-2 py-0.5 rounded text-xs bg-emerald-50 text-emerald-700">
                                   {instrument}
                                 </span>
                               ))}
-                          {track.classification.instruments.length > 6 && (
+                              {track.classification.instruments.length > 5 && (
-                            <span className="text-xs text-gray-400">+{track.classification.instruments.length - 6} more</span>
+                                <span className="text-xs text-slate-400">+{track.classification.instruments.length - 5}</span>
                               )}
                             </div>
                           )}
                         </div>
-                    <div className="ml-4 flex gap-2">
-                      <button
-                        onClick={() => setCurrentTrack(track)}
-                        className="px-3 py-1 text-sm bg-blue-600 text-white rounded hover:bg-blue-700"
-                      >
-                        {currentTrack?.id === track.id ? '▶ Playing' : 'Play'}
-                      </button>
-                      <a
-                        href={`${process.env.NEXT_PUBLIC_API_URL}/api/audio/download/${track.id}`}
-                        download
-                        className="px-3 py-1 text-sm bg-gray-600 text-white rounded hover:bg-gray-700"
-                      >
-                        Download
-                      </a>
-                    </div>
                       </div>
                     </div>
                   ))}
                 </div>
-          )}
 
                 {/* Pagination */}
-          {tracksData && tracksData.total > limit && (
+                {totalPages > 1 && (
-            <div className="p-4 border-t flex justify-between items-center">
+                  <div className="mt-8 flex items-center justify-between">
                     <button
                       onClick={() => setPage(p => Math.max(0, p - 1))}
                       disabled={page === 0}
-                className="px-4 py-2 bg-gray-200 rounded disabled:opacity-50"
+                      className="px-4 py-2 text-sm font-medium text-slate-700 bg-white border border-slate-300 rounded-lg hover:bg-slate-50 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
                     >
-                Previous
+                      ← Précédent
                     </button>
-              <span className="text-sm text-gray-600">
+
-                Page {page + 1} of {Math.ceil(tracksData.total / limit)}
+                    <div className="flex items-center gap-2">
+                      <span className="text-sm text-slate-600">
+                        Page <span className="font-semibold">{page + 1}</span> sur <span className="font-semibold">{totalPages}</span>
                       </span>
+                    </div>
+
                     <button
                       onClick={() => setPage(p => p + 1)}
-                disabled={(page + 1) * limit >= tracksData.total}
+                      disabled={(page + 1) >= totalPages}
-                className="px-4 py-2 bg-gray-200 rounded disabled:opacity-50"
+                      className="px-4 py-2 text-sm font-medium text-slate-700 bg-white border border-slate-300 rounded-lg hover:bg-slate-50 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
                     >
-                Next
+                      Suivant →
                     </button>
                   </div>
                 )}
-        </div>
+              </>
-
+            )}
-        {/* Instructions */}
-        <div className="mt-8 bg-blue-50 border border-blue-200 rounded-lg p-6">
-          <h3 className="font-semibold text-blue-900 mb-2">Getting Started</h3>
-          <ol className="list-decimal list-inside space-y-1 text-blue-800 text-sm">
-            <li>Make sure the backend is running (<code>docker-compose up</code>)</li>
-            <li>Use the API to analyze your audio library:
-              <pre className="mt-2 bg-blue-100 p-2 rounded text-xs">
-                {`curl -X POST http://localhost:8000/api/analyze/folder \\
-  -H "Content-Type: application/json" \\
-  -d '{"path": "/audio/your_music", "recursive": true}'`}
-              </pre>
-            </li>
-            <li>Refresh this page to see your analyzed tracks</li>
-          </ol>
           </div>
         </main>
+      </div>
 
-      {/* Fixed Audio Player at bottom - always visible */}
+      {/* Fixed Audio Player at bottom */}
       <div className="fixed bottom-0 left-0 right-0 z-50">
-        <AudioPlayer track={currentTrack} />
+        <AudioPlayer
+          track={currentTrack}
+          isPlaying={isPlaying}
+          onPlayingChange={setIsPlaying}
+        />
       </div>
     </div>
   )

frontend/components/AudioPlayer.tsx

@@ -2,13 +2,15 @@
 
 import { useState, useRef, useEffect } from "react"
 import type { Track } from "@/lib/types"
+import { getApiUrl } from "@/lib/api"
 
 interface AudioPlayerProps {
   track: Track | null
+  isPlaying: boolean
+  onPlayingChange: (playing: boolean) => void
 }
 
-export default function AudioPlayer({ track }: AudioPlayerProps) {
+export default function AudioPlayer({ track, isPlaying, onPlayingChange }: AudioPlayerProps) {
-  const [isPlaying, setIsPlaying] = useState(false)
   const [currentTime, setCurrentTime] = useState(0)
   const [duration, setDuration] = useState(0)
   const [volume, setVolume] = useState(1)
@@ -22,7 +24,7 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
   // Load audio and waveform when track changes
   useEffect(() => {
     if (!track) {
-      setIsPlaying(false)
+      onPlayingChange(false)
       setCurrentTime(0)
       setWaveformPeaks([])
       return
@@ -33,14 +35,14 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
 
     if (audioRef.current) {
       audioRef.current.load()
-      // Autoplay when track loads
+      // Autoplay when track loads if isPlaying is true
-      audioRef.current.play().then(() => {
+      if (isPlaying) {
-        setIsPlaying(true)
+        audioRef.current.play().catch((error: unknown) => {
-      }).catch((error: unknown) => {
           console.error("Autoplay failed:", error)
-        setIsPlaying(false)
+          onPlayingChange(false)
         })
       }
+    }
   }, [track?.id])
 
   // Update current time as audio plays
@@ -54,7 +56,7 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
         setDuration(audio.duration)
       }
     }
-    const handleEnded = () => setIsPlaying(false)
+    const handleEnded = () => onPlayingChange(false)
 
     audio.addEventListener("timeupdate", updateTime)
     audio.addEventListener("loadedmetadata", updateDuration)
@@ -77,8 +79,15 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
   const loadWaveform = async (trackId: string) => {
     setIsLoadingWaveform(true)
     try {
+      const token = localStorage.getItem('access_token')
+      const headers: HeadersInit = {}
+      if (token) {
+        headers['Authorization'] = `Bearer ${token}`
+      }
+
       const response = await fetch(
-        `${process.env.NEXT_PUBLIC_API_URL}/api/audio/waveform/${trackId}`
+        `${getApiUrl()}/api/audio/waveform/${trackId}`,
+        { headers }
       )
       if (response.ok) {
         const data = await response.json()
@@ -91,15 +100,24 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
     }
   }
 
-  const togglePlay = () => {
+  // Sync playing state with audio element
-    if (!audioRef.current || !track) return
+  useEffect(() => {
+    const audio = audioRef.current
+    if (!audio) return
 
     if (isPlaying) {
-      audioRef.current.pause()
+      audio.play().catch((error: unknown) => {
+        console.error("Play failed:", error)
+        onPlayingChange(false)
+      })
     } else {
-      audioRef.current.play()
+      audio.pause()
     }
-    setIsPlaying(!isPlaying)
+  }, [isPlaying, onPlayingChange])
+
+  const togglePlay = () => {
+    if (!audioRef.current || !track) return
+    onPlayingChange(!isPlaying)
   }
 
   const handleVolumeChange = (e: React.ChangeEvent<HTMLInputElement>) => {
@@ -148,10 +166,19 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
 
   const progress = duration > 0 ? (currentTime / duration) * 100 : 0
 
+  const getAuthenticatedStreamUrl = (trackId: string) => {
+    const token = localStorage.getItem('access_token')
+    const baseUrl = `${getApiUrl()}/api/audio/stream/${trackId}`
+    if (token) {
+      return `${baseUrl}?token=${encodeURIComponent(token)}`
+    }
+    return baseUrl
+  }
+
   return (
     <div className="bg-gray-50 border-t border-gray-300 shadow-lg" style={{ height: '80px' }}>
       {/* Hidden audio element */}
-      {track && <audio ref={audioRef} src={`${process.env.NEXT_PUBLIC_API_URL}/api/audio/stream/${track.id}`} />}
+      {track && <audio ref={audioRef} src={getAuthenticatedStreamUrl(track.id)} />}
 
       <div className="h-full flex items-center gap-3 px-4">
         {/* Play/Pause button */}
@@ -290,7 +317,7 @@ export default function AudioPlayer({ track }: AudioPlayerProps) {
         {/* Download button */}
         {track && (
           <a
-            href={`${process.env.NEXT_PUBLIC_API_URL}/api/audio/download/${track.id}`}
+            href={getAuthenticatedStreamUrl(track.id).replace('/stream/', '/download/')}
             download
             className="w-8 h-8 flex items-center justify-center text-gray-600 hover:text-gray-900 transition-colors rounded hover:bg-gray-200 flex-shrink-0"
             aria-label="Download"

frontend/components/AuthGuard.tsx

@@ -0,0 +1,37 @@
+"use client"
+
+import { useEffect, useState } from "react"
+import { useRouter, usePathname } from "next/navigation"
+import { isAuthenticated } from "@/lib/auth"
+
+export default function AuthGuard({ children }: { children: React.ReactNode }) {
+  const router = useRouter()
+  const pathname = usePathname()
+  const [isChecking, setIsChecking] = useState(true)
+
+  useEffect(() => {
+    // Skip auth check for login page
+    if (pathname === "/login") {
+      setIsChecking(false)
+      return
+    }
+
+    // Check if user is authenticated
+    if (!isAuthenticated()) {
+      router.push("/login")
+    } else {
+      setIsChecking(false)
+    }
+  }, [pathname, router])
+
+  // Show loading while checking auth
+  if (isChecking && pathname !== "/login") {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-gray-900">
+        <div className="text-white">Loading...</div>
+      </div>
+    )
+  }
+
+  return <>{children}</>
+}

frontend/components/FilterPanel.tsx

@@ -22,7 +22,6 @@ export default function FilterPanel({
 }: FilterPanelProps) {
   const [localFilters, setLocalFilters] = useState<FilterParams>(filters)
 
-  // Update local filters when parent changes
   useEffect(() => {
     setLocalFilters(filters)
   }, [filters])
@@ -39,34 +38,34 @@ export default function FilterPanel({
     onFiltersChange(emptyFilters)
   }
 
-  const hasActiveFilters = Object.keys(localFilters).length > 0
+  const hasActiveFilters = Object.keys(localFilters).filter(key =>
+    localFilters[key as keyof FilterParams] !== undefined &&
+    localFilters[key as keyof FilterParams] !== ""
+  ).length > 0
 
   return (
-    <div className="bg-white rounded-lg shadow p-4 mb-6">
+    <div className="space-y-6">
-      <div className="flex justify-between items-center mb-4">
+      {/* Clear all button */}
-        <h2 className="text-lg font-semibold text-gray-900">Filters</h2>
       {hasActiveFilters && (
         <button
           onClick={clearFilters}
-            className="text-sm text-blue-600 hover:text-blue-800"
+          className="w-full text-sm text-orange-600 hover:text-orange-700 font-medium py-2 px-3 bg-orange-50 rounded-lg hover:bg-orange-100 transition-colors"
         >
-            Clear all
+          Effacer tous les filtres
         </button>
       )}
-      </div>
 
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
       {/* Genre Filter */}
       <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
+        <label className="block text-sm font-semibold text-slate-700 mb-2">
           Genre
         </label>
         <select
           value={localFilters.genre || ""}
           onChange={(e) => handleFilterChange("genre", e.target.value || undefined)}
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+          className="w-full px-3 py-2 bg-slate-50 border border-slate-300 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-transparent"
         >
-            <option value="">All Genres</option>
+          <option value="">Tous les genres</option>
           {availableGenres.map((genre) => (
             <option key={genre} value={genre}>
               {genre}
@@ -77,15 +76,15 @@ export default function FilterPanel({
 
       {/* Mood Filter */}
       <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
+        <label className="block text-sm font-semibold text-slate-700 mb-2">
-            Mood
+          Ambiance
         </label>
         <select
           value={localFilters.mood || ""}
           onChange={(e) => handleFilterChange("mood", e.target.value || undefined)}
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+          className="w-full px-3 py-2 bg-slate-50 border border-slate-300 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-transparent"
         >
-            <option value="">All Moods</option>
+          <option value="">Toutes les ambiances</option>
           {availableMoods.map((mood) => (
             <option key={mood} value={mood}>
               {mood}
@@ -94,36 +93,53 @@ export default function FilterPanel({
         </select>
       </div>
 
-        {/* Instrument Filter */}
+      {/* Instrument Filter - Multiple Selection */}
       <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
+        <label className="block text-sm font-semibold text-slate-700 mb-2">
-            Instrument
+          Instruments
         </label>
-          <select
+        <div className="space-y-2 max-h-48 overflow-y-auto bg-slate-50 border border-slate-300 rounded-lg p-2">
-            value={localFilters.instrument || ""}
+          {availableInstruments.length === 0 ? (
-            onChange={(e) => handleFilterChange("instrument", e.target.value || undefined)}
+            <p className="text-xs text-slate-500 p-2">Aucun instrument disponible</p>
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+          ) : (
+            availableInstruments.map((instrument) => {
+              const isSelected = localFilters.instruments?.includes(instrument) || false
+              return (
+                <label
+                  key={instrument}
+                  className="flex items-center gap-2 p-2 hover:bg-slate-100 rounded cursor-pointer transition-colors"
                 >
-            <option value="">All Instruments</option>
+                  <input
-            {availableInstruments.map((instrument) => (
+                    type="checkbox"
-              <option key={instrument} value={instrument}>
+                    checked={isSelected}
-                {instrument}
+                    onChange={(e) => {
-              </option>
+                      const currentInstruments = localFilters.instruments || []
-            ))}
+                      const newInstruments = e.target.checked
-          </select>
+                        ? [...currentInstruments, instrument]
+                        : currentInstruments.filter(i => i !== instrument)
+                      handleFilterChange("instruments", newInstruments.length > 0 ? newInstruments : undefined)
+                    }}
+                    className="w-4 h-4 text-orange-500 border-slate-300 rounded focus:ring-2 focus:ring-orange-500 focus:ring-offset-0"
+                  />
+                  <span className="text-sm text-slate-700">{instrument}</span>
+                </label>
+              )
+            })
+          )}
+        </div>
       </div>
 
       {/* Key Filter */}
       <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
+        <label className="block text-sm font-semibold text-slate-700 mb-2">
-            Key
+          Tonalité
         </label>
         <select
           value={localFilters.key || ""}
           onChange={(e) => handleFilterChange("key", e.target.value || undefined)}
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+          className="w-full px-3 py-2 bg-slate-50 border border-slate-300 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-transparent"
         >
-            <option value="">All Keys</option>
+          <option value="">Toutes les tonalités</option>
           {availableKeys.map((key) => (
             <option key={key} value={key}>
               {key}
@@ -134,114 +150,68 @@ export default function FilterPanel({
 
       {/* Tempo Range Filter */}
       <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
+        <label className="block text-sm font-semibold text-slate-700 mb-2">
           Tempo
         </label>
         <select
           value={localFilters.tempo_range || ""}
           onChange={(e) => handleFilterChange("tempo_range", e.target.value || undefined)}
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
+          className="w-full px-3 py-2 bg-slate-50 border border-slate-300 rounded-lg text-sm focus:outline-none focus:ring-2 focus:ring-orange-500 focus:border-transparent"
         >
-            <option value="">All Tempos</option>
+          <option value="">Tous les tempos</option>
-            <option value="slow">Slow (&lt;100 BPM)</option>
+          <option value="slow">Lent (&lt; 100 BPM)</option>
-            <option value="medium">Medium (100-140 BPM)</option>
+          <option value="medium">Moyen (100-140 BPM)</option>
-            <option value="fast">Fast (&gt;140 BPM)</option>
+          <option value="fast">Rapide (&gt; 140 BPM)</option>
         </select>
       </div>
 
-        {/* Sort By */}
+      {/* Active filters summary */}
-        <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
-            Sort By
-          </label>
-          <select
-            value={localFilters.sort_by || "analyzed_at"}
-            onChange={(e) => handleFilterChange("sort_by", e.target.value as any)}
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
-          >
-            <option value="analyzed_at">Date Added</option>
-            <option value="filename">Filename</option>
-            <option value="tempo_bpm">BPM</option>
-            <option value="duration_seconds">Duration</option>
-            <option value="energy">Energy</option>
-          </select>
-        </div>
-
-        {/* Sort Order */}
-        <div>
-          <label className="block text-sm font-medium text-gray-700 mb-1">
-            Order
-          </label>
-          <select
-            value={localFilters.sort_desc ? "desc" : "asc"}
-            onChange={(e) => handleFilterChange("sort_desc", e.target.value === "desc")}
-            className="w-full px-3 py-2 border border-gray-300 rounded-md text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
-          >
-            <option value="asc">Ascending</option>
-            <option value="desc">Descending</option>
-          </select>
-        </div>
-      </div>
-
-      {/* Active Filters Display */}
       {hasActiveFilters && (
-        <div className="mt-4 flex flex-wrap gap-2">
+        <div className="pt-4 border-t border-slate-200">
+          <p className="text-xs font-semibold text-slate-700 mb-2">Filtres actifs:</p>
+          <div className="space-y-1">
             {localFilters.genre && (
-            <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-blue-100 text-blue-800">
+              <div className="flex items-center justify-between text-xs">
-              Genre: {localFilters.genre}
+                <span className="text-slate-600">Genre:</span>
-              <button
+                <span className="font-medium text-slate-800">{localFilters.genre}</span>
-                onClick={() => handleFilterChange("genre", undefined)}
+              </div>
-                className="ml-1 hover:text-blue-900"
-              >
-                ×
-              </button>
-            </span>
             )}
             {localFilters.mood && (
-            <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-purple-100 text-purple-800">
+              <div className="flex items-center justify-between text-xs">
-              Mood: {localFilters.mood}
+                <span className="text-slate-600">Ambiance:</span>
-              <button
+                <span className="font-medium text-slate-800">{localFilters.mood}</span>
-                onClick={() => handleFilterChange("mood", undefined)}
+              </div>
-                className="ml-1 hover:text-purple-900"
-              >
-                ×
-              </button>
-            </span>
             )}
-          {localFilters.instrument && (
+            {localFilters.instruments && localFilters.instruments.length > 0 && (
-            <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-green-100 text-green-800">
+              <div className="text-xs">
-              Instrument: {localFilters.instrument}
+                <span className="text-slate-600">Instruments:</span>
-              <button
+                <div className="flex flex-wrap gap-1 mt-1">
-                onClick={() => handleFilterChange("instrument", undefined)}
+                  {localFilters.instruments.map((instrument) => (
-                className="ml-1 hover:text-green-900"
+                    <span key={instrument} className="inline-flex items-center px-2 py-0.5 rounded text-xs bg-emerald-50 text-emerald-700">
-              >
+                      {instrument}
-                ×
-              </button>
                     </span>
+                  ))}
+                </div>
+              </div>
             )}
             {localFilters.key && (
-            <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-yellow-100 text-yellow-800">
+              <div className="flex items-center justify-between text-xs">
-              Key: {localFilters.key}
+                <span className="text-slate-600">Tonalité:</span>
-              <button
+                <span className="font-medium text-slate-800">{localFilters.key}</span>
-                onClick={() => handleFilterChange("key", undefined)}
+              </div>
-                className="ml-1 hover:text-yellow-900"
-              >
-                ×
-              </button>
-            </span>
             )}
             {localFilters.tempo_range && (
-            <span className="inline-flex items-center px-2 py-1 rounded text-xs bg-orange-100 text-orange-800">
+              <div className="flex items-center justify-between text-xs">
-              Tempo: {localFilters.tempo_range}
+                <span className="text-slate-600">Tempo:</span>
-              <button
+                <span className="font-medium text-slate-800">
-                onClick={() => handleFilterChange("tempo_range", undefined)}
+                  {localFilters.tempo_range === 'slow' && 'Lent'}
-                className="ml-1 hover:text-orange-900"
+                  {localFilters.tempo_range === 'medium' && 'Moyen'}
-              >
+                  {localFilters.tempo_range === 'fast' && 'Rapide'}
-                ×
-              </button>
                 </span>
+              </div>
             )}
           </div>
+        </div>
       )}
     </div>
   )

frontend/generate-config.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+# Generate runtime configuration file
+
+echo "Generating runtime configuration..."
+echo "API URL: ${NEXT_PUBLIC_API_URL:-http://localhost:8001}"
+
+cat > /app/public/config.js << EOF
+// Runtime configuration generated at container startup
+window.__RUNTIME_CONFIG__ = {
+  API_URL: '${NEXT_PUBLIC_API_URL:-http://localhost:8001}'
+};
+EOF
+
+echo "Configuration generated successfully!"
+cat /app/public/config.js

frontend/lib/api.ts

@@ -14,28 +14,63 @@ import type {
   FilterParams,
 } from './types'
 
-const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000'
+// Get API URL from runtime config (injected at container startup) or fallback to env var
+export function getApiUrl(): string {
+  if (typeof window !== 'undefined' && (window as any).__RUNTIME_CONFIG__) {
+    return (window as any).__RUNTIME_CONFIG__.API_URL
+  }
+  return process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000'
+}
 
-const apiClient = axios.create({
+// Create axios instance dynamically to use runtime config
-  baseURL: API_BASE_URL,
+function getApiClient() {
+  const client = axios.create({
+    baseURL: getApiUrl(),
     headers: {
       'Content-Type': 'application/json',
     },
-})
+  })
+
+  // Add JWT token to requests if available
+  client.interceptors.request.use((config) => {
+    if (typeof window !== 'undefined') {
+      const token = localStorage.getItem('access_token')
+      if (token) {
+        config.headers.Authorization = `Bearer ${token}`
+      }
+    }
+    return config
+  })
+
+  // Handle 401 errors (redirect to login)
+  client.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (error.response?.status === 401 && typeof window !== 'undefined') {
+        localStorage.removeItem('access_token')
+        localStorage.removeItem('user')
+        window.location.href = '/login'
+      }
+      return Promise.reject(error)
+    }
+  )
+
+  return client
+}
 
 // Tracks
 export async function getTracks(params: FilterParams & { skip?: number; limit?: number }): Promise<TracksResponse> {
-  const response = await apiClient.get('/api/tracks', { params })
+  const response = await getApiClient().get('/api/tracks', { params })
   return response.data
 }
 
 export async function getTrack(id: string): Promise<Track> {
-  const response = await apiClient.get(`/api/tracks/${id}`)
+  const response = await getApiClient().get(`/api/tracks/${id}`)
   return response.data
 }
 
 export async function deleteTrack(id: string): Promise<void> {
-  await apiClient.delete(`/api/tracks/${id}`)
+  await getApiClient().delete(`/api/tracks/${id}`)
 }
 
 // Search
@@ -43,7 +78,7 @@ export async function searchTracks(
   query: string,
   filters?: { genre?: string; mood?: string; limit?: number }
 ): Promise<SearchResponse> {
-  const response = await apiClient.get('/api/search', {
+  const response = await getApiClient().get('/api/search', {
     params: { q: query, ...filters },
   })
   return response.data
@@ -51,7 +86,7 @@ export async function searchTracks(
 
 // Similar
 export async function getSimilarTracks(id: string, limit: number = 10): Promise<SimilarTracksResponse> {
-  const response = await apiClient.get(`/api/tracks/${id}/similar`, {
+  const response = await getApiClient().get(`/api/tracks/${id}/similar`, {
     params: { limit },
   })
   return response.data
@@ -59,30 +94,30 @@ export async function getSimilarTracks(id: string, limit: number = 10): Promise<
 
 // Analysis
 export async function analyzeFolder(request: AnalyzeFolderRequest): Promise<{ job_id: string }> {
-  const response = await apiClient.post('/api/analyze/folder', request)
+  const response = await getApiClient().post('/api/analyze/folder', request)
   return response.data
 }
 
 export async function getAnalyzeStatus(jobId: string): Promise<JobStatus> {
-  const response = await apiClient.get(`/api/analyze/status/${jobId}`)
+  const response = await getApiClient().get(`/api/analyze/status/${jobId}`)
   return response.data
 }
 
 export async function deleteJob(jobId: string): Promise<void> {
-  await apiClient.delete(`/api/analyze/job/${jobId}`)
+  await getApiClient().delete(`/api/analyze/job/${jobId}`)
 }
 
 // Audio
 export function getStreamUrl(trackId: string): string {
-  return `${API_BASE_URL}/api/audio/stream/${trackId}`
+  return `${getApiUrl()}/api/audio/stream/${trackId}`
 }
 
 export function getDownloadUrl(trackId: string): string {
-  return `${API_BASE_URL}/api/audio/download/${trackId}`
+  return `${getApiUrl()}/api/audio/download/${trackId}`
 }
 
 export async function getWaveform(trackId: string, numPeaks: number = 800): Promise<WaveformData> {
-  const response = await apiClient.get(`/api/audio/waveform/${trackId}`, {
+  const response = await getApiClient().get(`/api/audio/waveform/${trackId}`, {
     params: { num_peaks: numPeaks },
   })
   return response.data
@@ -90,14 +125,12 @@ export async function getWaveform(trackId: string, numPeaks: number = 800): Prom
 
 // Stats
 export async function getStats(): Promise<Stats> {
-  const response = await apiClient.get('/api/stats')
+  const response = await getApiClient().get('/api/stats')
   return response.data
 }
 
 // Health
 export async function healthCheck(): Promise<{ status: string }> {
-  const response = await apiClient.get('/health')
+  const response = await getApiClient().get('/health')
   return response.data
 }
-
-export default apiClient

frontend/lib/auth.ts

@@ -0,0 +1,34 @@
+/**
+ * Authentication utilities
+ */
+
+export function getToken(): string | null {
+  if (typeof window === "undefined") return null
+  return localStorage.getItem("access_token")
+}
+
+export function setToken(token: string): void {
+  localStorage.setItem("access_token", token)
+}
+
+export function removeToken(): void {
+  localStorage.removeItem("access_token")
+  localStorage.removeItem("user")
+}
+
+export function getUser(): any | null {
+  if (typeof window === "undefined") return null
+  const user = localStorage.getItem("user")
+  return user ? JSON.parse(user) : null
+}
+
+export function isAuthenticated(): boolean {
+  return getToken() !== null
+}
+
+export function logout(): void {
+  removeToken()
+  if (typeof window !== "undefined") {
+    window.location.href = "/login"
+  }
+}

frontend/lib/types.ts

@@ -60,6 +60,7 @@ export interface FilterParams {
   has_vocals?: boolean
   key?: string
   instrument?: string
+  instruments?: string[] // Multiple instruments filter
   tempo_range?: 'slow' | 'medium' | 'fast' // Lent (<100), Moyen (100-140), Rapide (>140)
   sort_by?: 'analyzed_at' | 'tempo_bpm' | 'duration_seconds' | 'filename' | 'energy'
   sort_desc?: boolean

frontend/middleware.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server'
+import type { NextRequest } from 'next/server'
+
+export function middleware(request: NextRequest) {
+  // Middleware runs on server, can't access localStorage
+  // Auth check will be done client-side in layout.tsx
+  return NextResponse.next()
+}
+
+export const config = {
+  matcher: [
+    /*
+     * Match all request paths except for the ones starting with:
+     * - _next/static (static files)
+     * - _next/image (image optimization files)
+     * - favicon.ico (favicon file)
+     */
+    '/((?!_next/static|_next/image|favicon.ico).*)',
+  ],
+}

frontend/public/config.js

@@ -0,0 +1,4 @@
+// This file will be overwritten at container startup
+window.__RUNTIME_CONFIG__ = {
+  API_URL: 'http://localhost:8001'
+};

scripts/download-essentia-models.sh

@@ -1,73 +0,0 @@
-#!/usr/bin/env bash
-
-# Download Essentia models for audio classification
-# Models from: https://essentia.upf.edu/models.html
-
-set -e  # Exit on error
-
-MODELS_DIR="backend/models"
-CLASS_HEADS_URL="https://essentia.upf.edu/models/classification-heads"
-EMBEDDINGS_URL="https://essentia.upf.edu/models/feature-extractors/discogs-effnet"
-
-echo "📦 Downloading Essentia models..."
-echo "Models directory: $MODELS_DIR"
-
-# Create models directory if it doesn't exist
-mkdir -p "$MODELS_DIR"
-
-# Download function
-download_model() {
-    local model_file="$1"
-    local url="$2"
-    local output_path="$MODELS_DIR/$model_file"
-
-    if [ -f "$output_path" ]; then
-        echo "✓ $model_file already exists, skipping..."
-    else
-        echo "⬇️  Downloading $model_file..."
-        # Use -k flag to ignore SSL certificate issues with essentia.upf.edu
-        curl -k -L -o "$output_path" "$url"
-
-        if [ -f "$output_path" ] && [ -s "$output_path" ]; then
-            echo "✓ Downloaded $model_file ($(du -h "$output_path" | cut -f1))"
-        else
-            echo "✗ Failed to download $model_file"
-            rm -f "$output_path"  # Remove empty/failed file
-            exit 1
-        fi
-    fi
-}
-
-# Download embedding model first (required for all classification heads)
-echo ""
-echo "Downloading embedding model..."
-download_model "discogs-effnet-bs64-1.pb" \
-    "$EMBEDDINGS_URL/discogs-effnet-bs64-1.pb"
-
-# Download classification heads
-echo ""
-echo "Downloading classification heads..."
-
-# Genre: Discogs400 (professional taxonomy with 400 genres)
-download_model "genre_discogs400-discogs-effnet-1.pb" \
-    "$CLASS_HEADS_URL/genre_discogs400/genre_discogs400-discogs-effnet-1.pb"
-
-download_model "genre_discogs400-discogs-effnet-1.json" \
-    "$CLASS_HEADS_URL/genre_discogs400/genre_discogs400-discogs-effnet-1.json"
-
-# Mood & Instrument: MTG-Jamendo
-download_model "mtg_jamendo_moodtheme-discogs-effnet-1.pb" \
-    "$CLASS_HEADS_URL/mtg_jamendo_moodtheme/mtg_jamendo_moodtheme-discogs-effnet-1.pb"
-
-download_model "mtg_jamendo_instrument-discogs-effnet-1.pb" \
-    "$CLASS_HEADS_URL/mtg_jamendo_instrument/mtg_jamendo_instrument-discogs-effnet-1.pb"
-
-echo ""
-echo "✅ All models downloaded successfully!"
-echo ""
-echo "Models available:"
-ls -lh "$MODELS_DIR"/*.pb 2>/dev/null || echo "No .pb files found"
-
-echo ""
-echo "Note: Class labels are defined in backend/src/core/essentia_classifier.py"
-echo "You can now start the backend with: docker-compose up"