feat: Enhance AI service and configuration for MiniMax Music 3 integration

Dockerfile

@@ -7,6 +7,7 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements and install

app/core/config.py

@@ -1,19 +1,37 @@
-import os
-from pydantic_settings import BaseSettings
-from typing import List
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import List, Optional, Union
 
 class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
     APP_NAME: str = "NaijaSound-Mini"
-    DEBUG: bool = True
+    DEBUG: Union[bool, str] = True
 
     # Groq for Lyrics
-    GROQ_API_KEY: str = os.getenv("GROQ_API_KEY", "")
+    GROQ_API_KEY: str = ""
     GROQ_BASE_URL: str = "https://api.groq.com/openai/v1"
-    GROQ_MODEL: str = "llama-3.3-70b-versatile"
+    GROQ_LYRICS_MODEL: str = "openai/gpt-oss-20b"
+    GROQ_MODEL: Optional[str] = None
 
-    # MiniMax Music 3 Local Inference Server (SGLang-Omni)
-    MINIMAX_SERVER_URL: str = os.getenv("MINIMAX_SERVER_URL", "http://127.0.0.1:8000")
+    # MiniMax Music 3 local Diffusers pipeline.
+    AI_API_BASE_URL: str = "http://127.0.0.1:8000/v1"
+    AI_MUSIC_MODEL: str = "MiniMaxAI/MiniMax-Music3"
+    MINIMAX_SERVER_URL: Optional[str] = None
+    MINIMAX_AUDIO_DURATION_SECONDS: float = 60.0
+    MINIMAX_SEED: int = 7
+    MINIMAX_LOW_VRAM: bool = False
 
     CORS_ORIGINS: List[str] = ["*"]
 
+    @property
+    def groq_model_name(self) -> str:
+        return self.GROQ_MODEL or self.GROQ_LYRICS_MODEL
+
+    @property
+    def minimax_audio_speech_url(self) -> str:
+        base_url = (self.MINIMAX_SERVER_URL or self.AI_API_BASE_URL).rstrip("/")
+        if base_url.endswith("/v1"):
+            return f"{base_url}/audio/speech"
+        return f"{base_url}/v1/audio/speech"
+
 settings = Settings()

app/services/ai_service.py

@@ -1,3 +1,6 @@
+import asyncio
+import base64
+import io
 import logging
 import httpx
 from app.core.config import settings
@@ -7,6 +10,8 @@ logger = logging.getLogger(__name__)
 class AIService:
     def __init__(self):
         self.client = httpx.AsyncClient(timeout=120.0)
+        self.music_pipe = None
+        self.music_lock = asyncio.Lock()
 
     async def generate_naija_lyrics(self, theme: str):
         """Generate Afrobeats lyrics using Groq."""
@@ -25,7 +30,7 @@ class AIService:
                 f"{settings.GROQ_BASE_URL}/chat/completions",
                 headers={"Authorization": f"Bearer {settings.GROQ_API_KEY}"},
                 json={
-                    "model": settings.GROQ_MODEL,
+                    "model": settings.groq_model_name,
                     "messages": [{"role": "user", "content": prompt}]
                 }
             )
@@ -33,10 +38,10 @@ class AIService:
             return response.json()["choices"][0]["message"]["content"]
         except Exception as e:
             logger.error(f"Groq error: {e}")
-            return f"Lyrics generation failed: {str(e)}"
+            return f"Error: Lyrics generation failed: {str(e)}"
 
     async def generate_naija_music(self, prompt: str, lyrics: str):
-        """Generate music using MiniMax Music 3 via a local SGLang-Omni server (no API key needed)."""
+        """Generate music using MiniMax Music 3 via the local Diffusers pipeline."""
 
         # Construct a structured music description for a Naija theme as per MiniMax Music 3 guidelines
         music_description = (
@@ -50,34 +55,78 @@ class AIService:
         )
 
         try:
-            # Using the /v1/audio/speech endpoint on the local SGLang-Omni server
-            response = await self.client.post(
-                f"{settings.MINIMAX_SERVER_URL}/v1/audio/speech",
-                headers={"Content-Type": "application/json"},
-                json={
-                    "model": "MiniMaxAI/MiniMax-Music3",
-                    "input": lyrics,
-                    "instructions": music_description,
-                    "response_format": "wav",
-                    "seed": 7,
-                    "max_new_tokens": 750,
-                    "stream": False
-                }
-            )
-            response.raise_for_status()
-
-            # The response is a binary WAV file
-            import base64
-            audio_b64 = base64.b64encode(response.content).decode("utf-8")
-
+            async with self.music_lock:
+                audio_b64 = await asyncio.to_thread(
+                    self._generate_music_wav_base64,
+                    music_description,
+                    lyrics,
+                )
             return {
                 "audio_base64": f"data:audio/wav;base64,{audio_b64}",
-                "model": "MiniMax-Music3",
+                "model": settings.AI_MUSIC_MODEL,
                 "format": "wav"
             }
         except Exception as e:
-            logger.error(f"MiniMax Local Server error: {e}")
-            return {"error": f"Music generation failed. Ensure SGLang-Omni is running at {settings.MINIMAX_SERVER_URL}. Error: {str(e)}"}
+            logger.error(f"MiniMax Diffusers error: {e}")
+            return {"error": f"Music generation failed. Ensure Diffusers, Torch, SoundFile, and a CUDA GPU are available. Error: {str(e)}"}
+
+    def _load_music_pipe(self):
+        if self.music_pipe is not None:
+            return self.music_pipe
+
+        try:
+            import torch
+            from diffusers import ComponentsManager, ModularPipeline
+            from diffusers.hooks import apply_group_offloading
+        except ImportError as e:
+            raise RuntimeError(
+                "MiniMax local generation dependencies are missing. Install diffusers from the MiniMax PR commit plus transformers, accelerate, torch, and soundfile."
+            ) from e
+
+        if not torch.cuda.is_available():
+            raise RuntimeError("MiniMax Music 3 requires a CUDA GPU for local Diffusers generation.")
+
+        if settings.MINIMAX_LOW_VRAM:
+            manager = ComponentsManager()
+            manager.enable_auto_cpu_offload(device="cuda")
+            pipe = ModularPipeline.from_pretrained(
+                settings.AI_MUSIC_MODEL,
+                components_manager=manager,
+            )
+        else:
+            pipe = ModularPipeline.from_pretrained(settings.AI_MUSIC_MODEL)
+
+        pipe.load_components(dtype=torch.bfloat16)
+
+        if settings.MINIMAX_LOW_VRAM:
+            apply_group_offloading(
+                pipe.language_model,
+                onload_device=torch.device("cuda"),
+                offload_type="leaf_level",
+                use_stream=True,
+            )
+        else:
+            pipe.to("cuda")
+
+        self.music_pipe = pipe
+        return pipe
+
+    def _generate_music_wav_base64(self, prompt: str, lyrics: str) -> str:
+        import soundfile as sf
+        import torch
+
+        pipe = self._load_music_pipe()
+        audio = pipe(
+            prompt=prompt,
+            lyrics=lyrics,
+            audio_duration=settings.MINIMAX_AUDIO_DURATION_SECONDS,
+            generator=torch.Generator("cuda").manual_seed(settings.MINIMAX_SEED),
+            output="audios",
+        )[0]
+
+        wav_buffer = io.BytesIO()
+        sf.write(wav_buffer, audio.T.float().cpu().numpy(), pipe.sampling_rate, format="WAV")
+        return base64.b64encode(wav_buffer.getvalue()).decode("utf-8")
 
     async def close(self):
         await self.client.aclose()

requirements.txt

@@ -4,3 +4,9 @@ uvicorn
 pydantic-settings
 httpx
 python-multipart
+openai
+git+https://github.com/huggingface/diffusers@dafe3733fcfdbf3c48915fe77be3aef65b5d6a2d
+transformers
+accelerate
+soundfile
+torch