Move LRM provider backend configuration to config.json

nickprotop · nickprotop · commit fb6f382edb96 · 2025-12-17T02:25:09.000+02:00
- Add LrmBackendsConfiguration with config classes for all 10 providers
- Update LrmTranslationProvider to read backend settings from config
- Add ValidateBackendConfiguration() for startup validation
- Fix IOptions&lt;CloudConfiguration&gt; to use direct singleton injection
- Update config.sample.json with full backends documentation
diff --git a/cloud/deploy/config.sample.json b/cloud/deploy/config.sample.json
@@ -93,6 +93,55 @@
   "lrmProvider": {
     "enabled": true,
     "enabledBackends": ["mymemory", "lingva"],
-    "selectionStrategy": "priority"
+    "selectionStrategy": "priority",
+    "backends": {
+      "myMemory": {
+        "rateLimitPerMinute": 20
+      },
+      "lingva": {
+        "instanceUrl": "https://lingva.ml",
+        "rateLimitPerMinute": 30
+      },
+      "deepL": {
+        "apiKey": "YOUR_DEEPL_API_KEY",
+        "useFreeApi": false,
+        "rateLimitPerMinute": 100
+      },
+      "google": {
+        "apiKey": "YOUR_GOOGLE_CLOUD_API_KEY",
+        "rateLimitPerMinute": 100
+      },
+      "openAI": {
+        "apiKey": "YOUR_OPENAI_API_KEY",
+        "model": "gpt-4o-mini",
+        "rateLimitPerMinute": 60
+      },
+      "claude": {
+        "apiKey": "YOUR_CLAUDE_API_KEY",
+        "model": "claude-3-5-sonnet-20241022",
+        "rateLimitPerMinute": 50
+      },
+      "azureOpenAI": {
+        "apiKey": "YOUR_AZURE_OPENAI_API_KEY",
+        "endpoint": "https://your-resource.openai.azure.com",
+        "deploymentName": "gpt-4",
+        "rateLimitPerMinute": 60
+      },
+      "azureTranslator": {
+        "apiKey": "YOUR_AZURE_TRANSLATOR_API_KEY",
+        "region": "westus",
+        "rateLimitPerMinute": 100
+      },
+      "libreTranslate": {
+        "apiKey": "",
+        "instanceUrl": "https://libretranslate.com",
+        "rateLimitPerMinute": 30
+      },
+      "ollama": {
+        "apiUrl": "http://localhost:11434",
+        "model": "llama3.2",
+        "rateLimitPerMinute": 10
+      }
+    }
   }
 }
diff --git a/cloud/src/LrmCloud.Api/Services/Translation/LrmTranslationProvider.cs b/cloud/src/LrmCloud.Api/Services/Translation/LrmTranslationProvider.cs
@@ -3,7 +3,6 @@
 using LocalizationManager.Core.Configuration;
 using LocalizationManager.Core.Translation;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Options;
 
 namespace LrmCloud.Api.Services.Translation;
 
@@ -16,9 +15,15 @@ public interface ILrmTranslationProvider
 {
     /// <summary>
     /// Translate text using LRM managed backends.
+    /// Note: Usage tracking is handled by CloudTranslationService, not here.
     /// </summary>
+    /// <param name="billableUserId">The user whose quota to check (org owner for org projects).</param>
+    /// <param name="sourceText">Text to translate.</param>
+    /// <param name="sourceLanguage">Source language code.</param>
+    /// <param name="targetLanguage">Target language code.</param>
+    /// <param name="context">Optional context for AI providers.</param>
     Task<LrmTranslationResult> TranslateAsync(
-        int userId,
+        int billableUserId,
         string sourceText,
         string sourceLanguage,
         string targetLanguage,
@@ -27,17 +32,20 @@ Task<LrmTranslationResult> TranslateAsync(
     /// <summary>
     /// Check if LRM provider is available (enabled and user has chars remaining).
     /// </summary>
-    Task<(bool Available, string? Reason)> IsAvailableAsync(int userId);
+    /// <param name="billableUserId">The user whose quota to check (org owner for org projects).</param>
+    Task<(bool Available, string? Reason)> IsAvailableAsync(int billableUserId);
 
     /// <summary>
     /// Check if user has sufficient LRM chars for the given text.
     /// </summary>
-    Task<bool> HasSufficientCharsAsync(int userId, int charCount);
+    /// <param name="billableUserId">The user whose quota to check (org owner for org projects).</param>
+    Task<bool> HasSufficientCharsAsync(int billableUserId, int charCount);
 
     /// <summary>
     /// Get the remaining LRM chars for a user.
     /// </summary>
-    Task<int> GetRemainingCharsAsync(int userId);
+    /// <param name="billableUserId">The user whose quota to check (org owner for org projects).</param>
+    Task<int> GetRemainingCharsAsync(int billableUserId);
 }
 
 public class LrmTranslationResult
@@ -62,18 +70,78 @@ public class LrmTranslationProvider : ILrmTranslationProvider
 
     public LrmTranslationProvider(
         AppDbContext db,
-        IOptions<CloudConfiguration> config,
+        CloudConfiguration config,
         ILogger<LrmTranslationProvider> logger,
         IServiceProvider serviceProvider)
     {
         _db = db;
-        _config = config.Value;
+        _config = config;
         _logger = logger;
         _serviceProvider = serviceProvider;
+
+        ValidateBackendConfiguration();
+    }
+
+    /// <summary>
+    /// Validate that enabled backends have required configuration.
+    /// Logs warnings for misconfigured backends on startup.
+    /// </summary>
+    private void ValidateBackendConfiguration()
+    {
+        if (!_config.LrmProvider.Enabled)
+        {
+            _logger.LogInformation("LRM provider is disabled");
+            return;
+        }
+
+        var backends = _config.LrmProvider.Backends;
+        var enabled = _config.LrmProvider.EnabledBackends;
+
+        if (!enabled.Any())
+        {
+            _logger.LogWarning("LRM provider is enabled but no backends are configured in EnabledBackends");
+            return;
+        }
+
+        foreach (var backend in enabled)
+        {
+            var (isConfigured, issue) = backend.ToLowerInvariant() switch
+            {
+                "mymemory" => (true, null),  // Free, always works
+                "lingva" => (true, null),    // Free, always works
+                "deepl" => (!string.IsNullOrEmpty(backends.DeepL?.ApiKey), "missing ApiKey"),
+                "google" => (!string.IsNullOrEmpty(backends.Google?.ApiKey), "missing ApiKey"),
+                "openai" => (!string.IsNullOrEmpty(backends.OpenAI?.ApiKey), "missing ApiKey"),
+                "claude" => (!string.IsNullOrEmpty(backends.Claude?.ApiKey), "missing ApiKey"),
+                "azureopenai" => (
+                    !string.IsNullOrEmpty(backends.AzureOpenAI?.ApiKey) && !string.IsNullOrEmpty(backends.AzureOpenAI?.Endpoint),
+                    "missing ApiKey or Endpoint"),
+                "azuretranslator" => (!string.IsNullOrEmpty(backends.AzureTranslator?.ApiKey), "missing ApiKey"),
+                "libretranslate" => (true, null),  // API key optional
+                "ollama" => (true, null),  // Local, no key needed
+                _ => (false, "unknown backend")
+            };
+
+            if (!isConfigured)
+            {
+                _logger.LogWarning(
+                    "LRM backend '{Backend}' is enabled but not properly configured: {Issue}. " +
+                    "Configure it in LrmProvider.Backends section of config.json",
+                    backend, issue);
+            }
+            else
+            {
+                _logger.LogDebug("LRM backend '{Backend}' is configured and ready", backend);
+            }
+        }
+
+        _logger.LogInformation(
+            "LRM provider initialized with {Count} backend(s): [{Backends}]",
+            enabled.Count, string.Join(", ", enabled));
     }
 
     public async Task<LrmTranslationResult> TranslateAsync(
-        int userId,
+        int billableUserId,
         string sourceText,
         string sourceLanguage,
         string targetLanguage,
@@ -88,8 +156,8 @@ public async Task<LrmTranslationResult> TranslateAsync(
             return result;
         }
 
-        // Check user's remaining chars
-        var remaining = await GetRemainingCharsAsync(userId);
+        // Check billable user's remaining chars
+        var remaining = await GetRemainingCharsAsync(billableUserId);
         if (remaining < sourceText.Length)
         {
             result.Error = $"Insufficient LRM translation quota. Need {sourceText.Length} chars, have {remaining} remaining.";
@@ -133,26 +201,24 @@ public async Task<LrmTranslationResult> TranslateAsync(
                 result.TranslatedText = response.TranslatedText;
                 result.FromCache = response.FromCache;
 
-                // Track usage (decrement user's char balance)
-                await TrackLrmUsageAsync(userId, sourceText.Length);
-
+                // Note: Usage tracking is handled by CloudTranslationService, not here
                 _logger.LogDebug(
-                    "LRM translation via {Backend}: {Chars} chars for user {UserId}",
-                    backend, sourceText.Length, userId);
+                    "LRM translation via {Backend}: {Chars} chars (billable to user {BillableUserId})",
+                    backend, sourceText.Length, billableUserId);
 
                 return result; // Success - return immediately
             }
             catch (Exception ex)
             {
-                _logger.LogWarning(ex, "LRM backend {Backend} failed, user {UserId}, trying next", backend, userId);
+                _logger.LogWarning(ex, "LRM backend {Backend} failed (billable user {BillableUserId}), trying next", backend, billableUserId);
                 errors.Add($"{backend}: {ex.Message}");
                 // Continue to next backend
             }
         }
 
         // All backends failed
         result.Error = $"All LRM backends failed: {string.Join("; ", errors)}";
-        _logger.LogError("All LRM backends failed for user {UserId}: {Errors}", userId, result.Error);
+        _logger.LogError("All LRM backends failed (billable user {BillableUserId}): {Errors}", billableUserId, result.Error);
 
         return result;
     }
@@ -267,49 +333,132 @@ private void ApplyPlatformConfig(ConfigurationModel config, string backend)
         config.Translation.ApiKeys ??= new TranslationApiKeys();
         config.Translation.AIProviders ??= new AIProviderConfiguration();
 
-        // Platform API keys from master secret (if configured)
-        // These are the keys WE own for the LRM service
-        var masterSecret = _config.ApiKeyMasterSecret;
+        var backends = _config.LrmProvider.Backends;
 
         switch (backend.ToLowerInvariant())
         {
+            case "mymemory":
+                var mm = backends.MyMemory ?? new LrmMyMemoryConfig();
+                config.Translation.AIProviders.MyMemory = new MyMemorySettings
+                {
+                    RateLimitPerMinute = mm.RateLimitPerMinute
+                };
+                break;
+
             case "lingva":
-                // Lingva is free, no API key needed
-                config.Translation.AIProviders.Lingva = new LingvaSettings();
+                var lingva = backends.Lingva ?? new LrmLingvaConfig();
+                config.Translation.AIProviders.Lingva = new LingvaSettings
+                {
+                    InstanceUrl = lingva.InstanceUrl,
+                    RateLimitPerMinute = lingva.RateLimitPerMinute
+                };
                 break;
 
-            case "mymemory":
-                // MyMemory is free, no API key needed
-                config.Translation.AIProviders.MyMemory = new MyMemorySettings();
+            case "deepl":
+                var deepl = backends.DeepL;
+                if (string.IsNullOrEmpty(deepl?.ApiKey))
+                {
+                    _logger.LogWarning("DeepL backend enabled but no API key configured in LrmProvider.Backends.DeepL");
+                    break;
+                }
+                config.Translation.ApiKeys.DeepL = deepl.ApiKey;
                 break;
 
-            // Future: Add platform-owned API keys for paid backends
-            // case "deepl":
-            //     config.Translation.ApiKeys.DeepL = GetPlatformApiKey("deepl");
-            //     break;
-        }
-    }
+            case "google":
+                var google = backends.Google;
+                if (string.IsNullOrEmpty(google?.ApiKey))
+                {
+                    _logger.LogWarning("Google backend enabled but no API key configured in LrmProvider.Backends.Google");
+                    break;
+                }
+                config.Translation.ApiKeys.Google = google.ApiKey;
+                break;
 
-    private async Task TrackLrmUsageAsync(int userId, int charsUsed)
-    {
-        var user = await _db.Users.FindAsync(userId);
-        if (user == null) return;
+            case "openai":
+                var openai = backends.OpenAI;
+                if (string.IsNullOrEmpty(openai?.ApiKey))
+                {
+                    _logger.LogWarning("OpenAI backend enabled but no API key configured in LrmProvider.Backends.OpenAI");
+                    break;
+                }
+                config.Translation.ApiKeys.OpenAI = openai.ApiKey;
+                config.Translation.AIProviders.OpenAI = new OpenAISettings
+                {
+                    Model = openai.Model,
+                    CustomSystemPrompt = openai.CustomSystemPrompt,
+                    RateLimitPerMinute = openai.RateLimitPerMinute
+                };
+                break;
 
-        user.TranslationCharsUsed += charsUsed;
-        user.UpdatedAt = DateTime.UtcNow;
+            case "claude":
+                var claude = backends.Claude;
+                if (string.IsNullOrEmpty(claude?.ApiKey))
+                {
+                    _logger.LogWarning("Claude backend enabled but no API key configured in LrmProvider.Backends.Claude");
+                    break;
+                }
+                config.Translation.ApiKeys.Claude = claude.ApiKey;
+                config.Translation.AIProviders.Claude = new ClaudeSettings
+                {
+                    Model = claude.Model,
+                    CustomSystemPrompt = claude.CustomSystemPrompt,
+                    RateLimitPerMinute = claude.RateLimitPerMinute
+                };
+                break;
 
-        // Reset usage if reset date has passed
-        if (user.TranslationCharsResetAt.HasValue && user.TranslationCharsResetAt < DateTime.UtcNow)
-        {
-            user.TranslationCharsUsed = charsUsed; // Reset and add current
-            user.TranslationCharsResetAt = DateTime.UtcNow.AddMonths(1);
-        }
-        else if (!user.TranslationCharsResetAt.HasValue)
-        {
-            // Set initial reset date
-            user.TranslationCharsResetAt = DateTime.UtcNow.AddMonths(1);
-        }
+            case "azureopenai":
+                var azureOai = backends.AzureOpenAI;
+                if (string.IsNullOrEmpty(azureOai?.ApiKey) || string.IsNullOrEmpty(azureOai?.Endpoint))
+                {
+                    _logger.LogWarning("AzureOpenAI backend enabled but missing ApiKey or Endpoint in LrmProvider.Backends.AzureOpenAI");
+                    break;
+                }
+                config.Translation.ApiKeys.AzureOpenAI = azureOai.ApiKey;
+                config.Translation.AIProviders.AzureOpenAI = new AzureOpenAISettings
+                {
+                    Endpoint = azureOai.Endpoint,
+                    DeploymentName = azureOai.DeploymentName,
+                    CustomSystemPrompt = azureOai.CustomSystemPrompt,
+                    RateLimitPerMinute = azureOai.RateLimitPerMinute
+                };
+                break;
+
+            case "azuretranslator":
+                var azureTr = backends.AzureTranslator;
+                if (string.IsNullOrEmpty(azureTr?.ApiKey))
+                {
+                    _logger.LogWarning("AzureTranslator backend enabled but no API key configured in LrmProvider.Backends.AzureTranslator");
+                    break;
+                }
+                config.Translation.ApiKeys.AzureTranslator = azureTr.ApiKey;
+                config.Translation.AIProviders.AzureTranslator = new AzureTranslatorSettings
+                {
+                    Region = azureTr.Region,
+                    Endpoint = azureTr.Endpoint,
+                    RateLimitPerMinute = azureTr.RateLimitPerMinute
+                };
+                break;
 
-        await _db.SaveChangesAsync();
+            case "libretranslate":
+                var libre = backends.LibreTranslate ?? new LrmLibreTranslateConfig();
+                config.Translation.ApiKeys.LibreTranslate = libre.ApiKey;
+                break;
+
+            case "ollama":
+                var ollama = backends.Ollama ?? new LrmOllamaConfig();
+                config.Translation.AIProviders.Ollama = new OllamaSettings
+                {
+                    ApiUrl = ollama.ApiUrl,
+                    Model = ollama.Model,
+                    CustomSystemPrompt = ollama.CustomSystemPrompt,
+                    RateLimitPerMinute = ollama.RateLimitPerMinute
+                };
+                break;
+
+            default:
+                _logger.LogWarning("Unknown LRM backend: {Backend}", backend);
+                break;
+        }
     }
+
 }
diff --git a/cloud/src/LrmCloud.Shared/Configuration/CloudConfiguration.cs b/cloud/src/LrmCloud.Shared/Configuration/CloudConfiguration.cs
