Merge pull request #24 from sd3420625/main

fspecii · web-flow · commit 5c3e4048a6c1 · 2026-01-27T20:41:42.000+02:00
feat: Add custom API support for OpenAI-compatible endpoints
diff --git a/backend/.env.example b/backend/.env.example
@@ -2,6 +2,12 @@
 # Get your key at https://openrouter.ai/
 OPENROUTER_API_KEY=your_openrouter_api_key_here
 
+# ===== Custom API (OpenAI Compatible) =====
+# For connecting to vLLM, LocalAI, LM Studio, or any OpenAI-compatible endpoint
+# CUSTOM_API_BASE_URL=http://localhost:8080/v1
+# CUSTOM_API_KEY=your_api_key_here
+# CUSTOM_API_MODEL=your-model-name
+
 # ===== GPU Configuration =====
 # Set to "true", "false", or "auto" (default: auto)
 # HEARTMULA_4BIT=auto
diff --git a/backend/app/main.py b/backend/app/main.py
@@ -651,15 +651,22 @@ async def reload_models(settings: GPUSettingsRequest, background_tasks: Backgrou
 def get_llm_settings():
     """Get current LLM provider settings."""
     settings = LLMService.get_settings()
-    # Mask API key for security (show only last 4 chars)
-    api_key = settings.get("openrouter_api_key", "")
-    masked_key = f"***{api_key[-4:]}" if api_key and len(api_key) > 4 else ""
+    # Mask API keys for security (show only last 4 chars)
+    openrouter_key = settings.get("openrouter_api_key", "")
+    masked_openrouter_key = f"***{openrouter_key[-4:]}" if openrouter_key and len(openrouter_key) > 4 else ""
+
+    custom_api_key = settings.get("custom_api_key", "")
+    masked_custom_key = f"***{custom_api_key[-4:]}" if custom_api_key and len(custom_api_key) > 4 else ""
 
     return {
         "ollama_host": settings.get("ollama_host", ""),
-        "openrouter_api_key": masked_key,
+        "openrouter_api_key": masked_openrouter_key,
         "ollama_available": LLMService.check_ollama_available(),
-        "openrouter_available": LLMService.check_openrouter_available()
+        "openrouter_available": LLMService.check_openrouter_available(),
+        "custom_api_base_url": settings.get("custom_api_base_url", ""),
+        "custom_api_key": masked_custom_key,
+        "custom_api_model": settings.get("custom_api_model", ""),
+        "custom_api_available": LLMService.check_custom_api_available()
     }
 
 
@@ -675,19 +682,38 @@ def update_llm_settings(settings: LLMSettingsRequest):
         LLMService.update_settings(openrouter_api_key=settings.openrouter_api_key)
         music_service.current_settings["openrouter_api_key"] = settings.openrouter_api_key
 
+    if settings.custom_api_base_url is not None:
+        LLMService.update_settings(custom_api_base_url=settings.custom_api_base_url)
+        music_service.current_settings["custom_api_base_url"] = settings.custom_api_base_url
+
+    if settings.custom_api_key is not None:
+        LLMService.update_settings(custom_api_key=settings.custom_api_key)
+        music_service.current_settings["custom_api_key"] = settings.custom_api_key
+
+    if settings.custom_api_model is not None:
+        LLMService.update_settings(custom_api_model=settings.custom_api_model)
+        music_service.current_settings["custom_api_model"] = settings.custom_api_model
+
     # Save to persistent storage
     music_service._save_settings()
 
     # Return updated settings
     current = LLMService.get_settings()
-    api_key = current.get("openrouter_api_key", "")
-    masked_key = f"***{api_key[-4:]}" if api_key and len(api_key) > 4 else ""
+    openrouter_key = current.get("openrouter_api_key", "")
+    masked_openrouter_key = f"***{openrouter_key[-4:]}" if openrouter_key and len(openrouter_key) > 4 else ""
+
+    custom_api_key = current.get("custom_api_key", "")
+    masked_custom_key = f"***{custom_api_key[-4:]}" if custom_api_key and len(custom_api_key) > 4 else ""
 
     return {
         "ollama_host": current.get("ollama_host", ""),
-        "openrouter_api_key": masked_key,
+        "openrouter_api_key": masked_openrouter_key,
         "ollama_available": LLMService.check_ollama_available(),
-        "openrouter_available": LLMService.check_openrouter_available()
+        "openrouter_available": LLMService.check_openrouter_available(),
+        "custom_api_base_url": current.get("custom_api_base_url", ""),
+        "custom_api_key": masked_custom_key,
+        "custom_api_model": current.get("custom_api_model", ""),
+        "custom_api_available": LLMService.check_custom_api_available()
     }
 
 
diff --git a/backend/app/models.py b/backend/app/models.py
@@ -155,10 +155,17 @@ class ModelReloadResponse(SQLModel):
 class LLMSettingsRequest(SQLModel):
     ollama_host: Optional[str] = None
     openrouter_api_key: Optional[str] = None
+    custom_api_base_url: Optional[str] = None
+    custom_api_key: Optional[str] = None
+    custom_api_model: Optional[str] = None
 
 
 class LLMSettingsResponse(SQLModel):
     ollama_host: str
     openrouter_api_key: str  # Will be masked in response
     ollama_available: bool
     openrouter_available: bool
+    custom_api_base_url: str
+    custom_api_key: str  # Will be masked in response
+    custom_api_model: str
+    custom_api_available: bool
diff --git a/backend/app/services/llm_service.py b/backend/app/services/llm_service.py
@@ -31,29 +31,50 @@
 # Default values from environment (can be overridden by settings)
 _DEFAULT_OPENROUTER_KEY = os.environ.get("OPENROUTER_API_KEY", "")
 _DEFAULT_OLLAMA_HOST = os.environ.get("OLLAMA_HOST", "http://localhost:11434")
+_DEFAULT_CUSTOM_API_BASE_URL = os.environ.get("CUSTOM_API_BASE_URL", "")
+_DEFAULT_CUSTOM_API_KEY = os.environ.get("CUSTOM_API_KEY", "")
+_DEFAULT_CUSTOM_API_MODEL = os.environ.get("CUSTOM_API_MODEL", "")
 
 class LLMService:
     # Configurable settings (can be updated at runtime)
     OLLAMA_BASE_URL = _DEFAULT_OLLAMA_HOST
     OPENROUTER_API_KEY = _DEFAULT_OPENROUTER_KEY
     OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+    # Custom API settings (OpenAI-compatible endpoints like vLLM, LocalAI, LM Studio)
+    CUSTOM_API_BASE_URL = _DEFAULT_CUSTOM_API_BASE_URL
+    CUSTOM_API_KEY = _DEFAULT_CUSTOM_API_KEY
+    CUSTOM_API_MODEL = _DEFAULT_CUSTOM_API_MODEL
 
     @classmethod
-    def update_settings(cls, ollama_host: str = None, openrouter_api_key: str = None):
+    def update_settings(cls, ollama_host: str = None, openrouter_api_key: str = None,
+                       custom_api_base_url: str = None, custom_api_key: str = None,
+                       custom_api_model: str = None):
         """Update LLM service settings at runtime."""
         if ollama_host is not None:
             cls.OLLAMA_BASE_URL = ollama_host if ollama_host else _DEFAULT_OLLAMA_HOST
             logger.info(f"[LLM] Updated Ollama host: {cls.OLLAMA_BASE_URL}")
         if openrouter_api_key is not None:
             cls.OPENROUTER_API_KEY = openrouter_api_key
             logger.info(f"[LLM] Updated OpenRouter API key: {'***' + openrouter_api_key[-4:] if openrouter_api_key else '(empty)'}")
+        if custom_api_base_url is not None:
+            cls.CUSTOM_API_BASE_URL = custom_api_base_url
+            logger.info(f"[LLM] Updated Custom API base URL: {cls.CUSTOM_API_BASE_URL or '(empty)'}")
+        if custom_api_key is not None:
+            cls.CUSTOM_API_KEY = custom_api_key
+            logger.info(f"[LLM] Updated Custom API key: {'***' + custom_api_key[-4:] if custom_api_key else '(empty)'}")
+        if custom_api_model is not None:
+            cls.CUSTOM_API_MODEL = custom_api_model
+            logger.info(f"[LLM] Updated Custom API model: {cls.CUSTOM_API_MODEL or '(empty)'}")
 
     @classmethod
     def get_settings(cls) -> dict:
         """Get current LLM service settings."""
         return {
             "ollama_host": cls.OLLAMA_BASE_URL,
-            "openrouter_api_key": cls.OPENROUTER_API_KEY
+            "openrouter_api_key": cls.OPENROUTER_API_KEY,
+            "custom_api_base_url": cls.CUSTOM_API_BASE_URL,
+            "custom_api_key": cls.CUSTOM_API_KEY,
+            "custom_api_model": cls.CUSTOM_API_MODEL
         }
 
     @classmethod
@@ -70,6 +91,11 @@ def check_openrouter_available(cls) -> bool:
         """Check if OpenRouter API key is set."""
         return bool(cls.OPENROUTER_API_KEY)
 
+    @classmethod
+    def check_custom_api_available(cls) -> bool:
+        """Check if Custom API is configured (base URL and model are required)."""
+        return bool(cls.CUSTOM_API_BASE_URL and cls.CUSTOM_API_MODEL)
+
     @classmethod
     def get_models(cls) -> List[dict]:
         """Returns available models from both Ollama and OpenRouter."""
@@ -99,6 +125,14 @@ def get_models(cls) -> List[dict]:
             ]
             models.extend(openrouter_models)
 
+        # Add Custom API model if configured
+        if cls.CUSTOM_API_BASE_URL and cls.CUSTOM_API_MODEL:
+            models.append({
+                "id": cls.CUSTOM_API_MODEL,
+                "name": f"Custom: {cls.CUSTOM_API_MODEL}",
+                "provider": "custom"
+            })
+
         return models
 
     @staticmethod
@@ -154,11 +188,41 @@ def _call_openrouter(cls, model: str, prompt: str, temperature: float = 0.7) ->
             return data["choices"][0]["message"]["content"]
         raise Exception(f"OpenRouter Error: {resp.status_code} - {resp.text}")
 
+    @classmethod
+    def _call_custom_api(cls, model: str, prompt: str, temperature: float = 0.7) -> str:
+        """Call a custom OpenAI-compatible API (vLLM, LocalAI, LM Studio, etc.)."""
+        headers = {"Content-Type": "application/json"}
+        if cls.CUSTOM_API_KEY:
+            headers["Authorization"] = f"Bearer {cls.CUSTOM_API_KEY}"
+
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": temperature
+        }
+
+        # Ensure base URL doesn't have trailing slash
+        base_url = cls.CUSTOM_API_BASE_URL.rstrip('/')
+
+        resp = requests.post(
+            f"{base_url}/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+
+        if resp.status_code == 200:
+            data = resp.json()
+            return data["choices"][0]["message"]["content"]
+        raise Exception(f"Custom API Error: {resp.status_code} - {resp.text}")
+
     @classmethod
     def _call_llm(cls, model: str, prompt: str, provider: str = "ollama", json_mode: bool = False, temperature: float = 0.7) -> str:
         """Unified LLM call that routes to appropriate provider."""
         if provider == "openrouter":
             return cls._call_openrouter(model, prompt, temperature)
+        elif provider == "custom":
+            return cls._call_custom_api(model, prompt, temperature)
         else:
             return cls._call_ollama(model, prompt, json_mode, temperature)
 
diff --git a/backend/app/services/music_service.py b/backend/app/services/music_service.py
@@ -755,7 +755,11 @@ def __new__(cls):
                 "torch_compile_mode": "default",
                 # LLM Provider settings
                 "ollama_host": "",
-                "openrouter_api_key": ""
+                "openrouter_api_key": "",
+                # Custom API settings
+                "custom_api_base_url": "",
+                "custom_api_key": "",
+                "custom_api_model": ""
             }
             # Load persisted settings from disk (overrides defaults)
             cls._instance._load_settings()
@@ -806,6 +810,13 @@ def _load_settings(self):
                         LLMService.update_settings(ollama_host=saved["ollama_host"])
                     if "openrouter_api_key" in saved and saved["openrouter_api_key"]:
                         LLMService.update_settings(openrouter_api_key=saved["openrouter_api_key"])
+                    # Apply Custom API settings
+                    if "custom_api_base_url" in saved:
+                        LLMService.update_settings(custom_api_base_url=saved["custom_api_base_url"])
+                    if "custom_api_key" in saved:
+                        LLMService.update_settings(custom_api_key=saved["custom_api_key"])
+                    if "custom_api_model" in saved:
+                        LLMService.update_settings(custom_api_model=saved["custom_api_model"])
 
                     logger.info(f"[Settings] Loaded from {SETTINGS_FILE}: {self.current_settings}")
         except Exception as e:
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
@@ -21,7 +21,7 @@ export interface Job {
 export interface LLMModel {
     id: string;
     name: string;
-    provider: 'ollama' | 'openrouter';
+    provider: 'ollama' | 'openrouter' | 'custom';
 }
 
 export interface Playlist {
@@ -77,6 +77,10 @@ export interface LLMSettings {
     openrouter_api_key: string;
     ollama_available: boolean;
     openrouter_available: boolean;
+    custom_api_base_url: string;
+    custom_api_key: string;
+    custom_api_model: string;
+    custom_api_available: boolean;
 }
 
 export const api = {
@@ -352,7 +356,13 @@ export const api = {
         return res.data;
     },
 
-    updateLLMSettings: async (settings: { ollama_host?: string; openrouter_api_key?: string }): Promise<LLMSettings> => {
+    updateLLMSettings: async (settings: {
+        ollama_host?: string;
+        openrouter_api_key?: string;
+        custom_api_base_url?: string;
+        custom_api_key?: string;
+        custom_api_model?: string;
+    }): Promise<LLMSettings> => {
         const res = await axios.put(`${API_BASE_URL}/settings/llm`, settings);
         return res.data;
     }
diff --git a/frontend/src/components/SettingsModal.tsx b/frontend/src/components/SettingsModal.tsx
