Merge Gradio UI into FastAPI app and standardize port to 7860

Dockerfile

@@ -21,8 +21,6 @@ ENV HOME=/home/user  \
 
 # Exposer le port sur lequel l'application va tourner
 EXPOSE 7860
-EXPOSE 8000
-
 
 # RUN --mount=type=secret,id=api_read,mode=0444,required=true \
 #     cat /run/secrets/api_read > /secret
@@ -31,4 +29,4 @@ EXPOSE 8000
 #   git clone $(cat /run/secrets/api_read)
 
 # Commande pour lancer l'application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,24 +0,0 @@
-# Interface Gradio pour afficher la liste des modèles chargés
-import gradio as gr
-import asyncio
-from db.models import fetch_models_for_group
-from models.loader import load_models, model_pipelines
-from config.settings import RESOURCE_GROUP
-
-async def init_models():
-    """Charger les modèles au démarrage"""
-    models_data = await fetch_models_for_group(RESOURCE_GROUP)
-    await load_models(models_data)
-
-# Initialisation des modèles
-asyncio.run(init_models())
-
-def get_model_list():
-    """Retourner la liste des modèles chargés"""
-    return list(model_pipelines.keys())
-
-with gr.Blocks() as demo:
-    demo.title("Tamis AI - Liste des modèles chargés")
-    gr.JSON(get_model_list)
-
-demo.launch()

docker-compose.yml

@@ -3,19 +3,9 @@ version: '3.8'
 services:
   api:
     build: .
-    command: uvicorn main:app --host 0.0.0.0 --port 8000
+    # Command is now defined in Dockerfile's CMD
     ports:
-      - "8000:8000"
-    volumes:
-      - .:/app
-    env_file:
-      - .env
-
-  ui:
-    build: .
-    command: python app.py
-    ports:
-      - "7860:7860"
+      - "7860:7860" # Expose Gradio/API port
     volumes:
       - .:/app
     env_file:

main.py

@@ -1,9 +1,11 @@
 import logging
 from fastapi import FastAPI
+import gradio as gr
+from gradio.routes import mount_gradio_app
 
 from api.router import router, verify_api_key
 from db.models import fetch_models_for_group
-from models.loader import load_models
+from models.loader import load_models, model_pipelines
 from config.settings import RESOURCE_GROUP
 
 # Configuration de base des logs
@@ -26,16 +28,42 @@ app.middleware("http")(verify_api_key)
 # Inclure les routes
 app.include_router(router)
 
+async def init_models():
+    """Charger les modèles au démarrage pour Gradio et FastAPI."""
+    logger.info("Initializing models for Gradio and FastAPI...")
+    try:
+        models_data = await fetch_models_for_group(RESOURCE_GROUP)
+        await load_models(models_data)
+        logger.info("Models loaded successfully.")
+    except Exception as e:
+        logger.error(f"Failed to initialize models: {e}", exc_info=True)
+        # Decide if the app should fail to start or continue without models
+        # raise RuntimeError("Model initialization failed.")
+        # For now, let's log and continue, Gradio will show an empty list
+        pass
+
+# Définir la fonction pour Gradio qui récupère les modèles chargés
+def get_loaded_models_list():
+    """Retourne la liste des noms de modèles actuellement chargés."""
+    return list(model_pipelines.keys())
+
+# Créer l'interface Gradio
+gradio_app = gr.Blocks(title="Tamis AI - Modèles Chargés")
+with gradio_app:
+    gr.Markdown("## Modèles actuellement chargés dans l'API")
+    gr.JSON(get_loaded_models_list, label="Modèles Chargés")
+
+# Monter l'application Gradio à la racine dans FastAPI
+app = mount_gradio_app(
+    app, gradio_app, path="/"
+)
+
+# Event startup to load models (ensure it runs *after* Gradio is mounted if needed)
+# We call init_models inside startup
 @app.on_event("startup")
 async def startup():
     """Initialiser l'API : charger les modèles depuis la base de données."""
-    logger.info("Starting API initialization...")
-    
-    # Charger les modèles depuis la base de données
-    models_data = await fetch_models_for_group(RESOURCE_GROUP)
-    await load_models(models_data)
-    
-    logger.info("API initialization complete.")
+    await init_models() # Call the consolidated init function
 
 @app.get("/health")
 async def health_check():