Mise en place docker + mise en place des settings (config ollama / 1min.ai)

brain/app/core/config.py

@@ -3,11 +3,18 @@
 Équivalent Python du `application.properties` Spring Boot, avec validation
 Pydantic : une variable manquante/invalide = crash au démarrage, pas une
 NullPointerException surprise à la 3ème requête.
+
+Depuis l'ecran Parametres (UI) : certains champs sont surchargeables a chaud
+via `settings_store` (fichier JSON). A chaque Depends(get_settings), on relit
+.env + overrides fusionnes. Pas de cache : le cout d'un read JSON local est
+negligeable face a un appel LLM.
 """
-from functools import lru_cache
+from typing import Literal
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from app.core.settings_store import load_overrides
+
 
 class Settings(BaseSettings):
     """Settings chargés depuis .env ou variables d'environnement."""
@@ -18,6 +25,9 @@ class Settings(BaseSettings):
         extra="ignore",
     )
 
+    # Provider LLM actif. "ollama" = local ; "onemin" = 1min.ai (etage 2).
+    llm_provider: Literal["ollama", "onemin"] = "ollama"
+
     ollama_base_url: str = "http://localhost:11434"
     llm_model: str = "gemma4:26b"
     llm_timeout_seconds: int = 120
@@ -29,8 +39,16 @@ class Settings(BaseSettings):
     # LLM_NUM_CTX dans .env si besoin (ex: VRAM limitée → 8192).
     llm_num_ctx: int = 16384
 
+    # 1min.ai (etage 2) — la cle et le modele sont stockes via settings_store
+    # (modifiables depuis l'UI). Les defauts ici sont juste des placeholders.
+    onemin_api_key: str = ""
+    onemin_model: str = "gpt-4o-mini"
+
 
-@lru_cache
 def get_settings() -> Settings:
-    """Singleton via cache — FastAPI l'injecte avec Depends() dans les routes."""
-    return Settings()
+    """Fabrique des Settings merges (.env -> overrides runtime).
+
+    Relu a chaque requete HTTP (via Depends). Permet a l'UI de changer
+    le modele / provider sans redemarrer le Brain.
+    """
+    return Settings(**load_overrides())

brain/app/core/settings_store.py

@@ -0,0 +1,41 @@
+"""Overrides runtime persistés sur disque pour les Settings.
+
+Les Settings par defaut viennent de .env (12-factor). L'utilisateur peut
+surcharger certains champs depuis l'UI (ex: modele Ollama choisi) — ces
+overrides sont stockes dans un fichier JSON local, relus a chaque requete.
+
+Thread-safe via un lock simple : suffisant pour un deploiement mono-process
+(usage local). Si un jour on passe en multi-worker, migrer vers SQLite.
+"""
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any
+
+_LOCK = threading.Lock()
+_OVERRIDES_PATH = Path("data/settings.json")
+
+
+def load_overrides() -> dict[str, Any]:
+    """Retourne le dict d'overrides, ou {} si le fichier n'existe pas / est corrompu."""
+    if not _OVERRIDES_PATH.exists():
+        return {}
+    try:
+        return json.loads(_OVERRIDES_PATH.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save_overrides(patch: dict[str, Any]) -> dict[str, Any]:
+    """Fusionne `patch` dans les overrides existants et persiste. Retourne l'etat final."""
+    with _LOCK:
+        current = load_overrides()
+        current.update(patch)
+        _OVERRIDES_PATH.parent.mkdir(parents=True, exist_ok=True)
+        _OVERRIDES_PATH.write_text(
+            json.dumps(current, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        return current