From 6c4e8808a8bd317a39c4faeb4a87643a5cee5dc3 Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Thu, 5 Mar 2026 15:38:27 +0100
Subject: [PATCH 1/9] Add settings UI for InferPage

Introduce a browser-based settings experience and improve model path resolution. Adds a Settings panel (Settings.razor) with styles and JS (settings.css, settings.js) and services to persist settings and API keys (SettingsService, InferPageSettings, SettingsStateService). Wire the settings UX into NavBar and Home to request/show/save settings and apply them at runtime via Utils.ApplySettings; Program.cs now distinguishes CLI-provided config vs browser configuration (Utils.NeedsConfiguration). Update Utils to support manual capability overrides and sanitize model paths, and tweak app CSS and script includes. Improve LLMService local model resolution and path handling (fallback GenericLocalModel, ResolvePath) so unregistered or absolute model paths load correctly.
---
 src/MaIN.InferPage/Components/App.razor       |   1 +
 .../Components/Layout/MainLayout.razor        |   4 +-
 .../Components/Layout/NavBar.razor            |  24 +
 .../Components/Pages/Home.razor               | 166 ++++++-
 .../Components/Pages/Settings.razor           | 422 ++++++++++++++++++
 src/MaIN.InferPage/Components/_Imports.razor  |   4 +-
 src/MaIN.InferPage/Program.cs                 | 103 +++--
 .../Services/InferPageSettings.cs             |  12 +
 .../Services/SettingsService.cs               |  68 +++
 .../Services/SettingsStateService.cs          |  21 +
 src/MaIN.InferPage/Utils.cs                   |  94 +++-
 src/MaIN.InferPage/wwwroot/app.css            |  23 +-
 src/MaIN.InferPage/wwwroot/settings.css       | 116 +++++
 src/MaIN.InferPage/wwwroot/settings.js        |  20 +
 .../Services/LLMService/LLMService.cs         |  58 ++-
 15 files changed, 1056 insertions(+), 80 deletions(-)
 create mode 100644 src/MaIN.InferPage/Components/Pages/Settings.razor
 create mode 100644 src/MaIN.InferPage/Services/InferPageSettings.cs
 create mode 100644 src/MaIN.InferPage/Services/SettingsService.cs
 create mode 100644 src/MaIN.InferPage/Services/SettingsStateService.cs
 create mode 100644 src/MaIN.InferPage/wwwroot/settings.css
 create mode 100644 src/MaIN.InferPage/wwwroot/settings.js

diff --git a/src/MaIN.InferPage/Components/App.razor b/src/MaIN.InferPage/Components/App.razor
index 889b8ac3..1150b373 100644
--- a/src/MaIN.InferPage/Components/App.razor
+++ b/src/MaIN.InferPage/Components/App.razor
@@ -27,6 +27,7 @@
 <script src="_framework/blazor.web.js"></script>
 <script src="scroll.js"></script>
 <script src="editor.js"></script>
+<script src="settings.js"></script>
 <script>
     window.themeManager = {
         save: function (theme) { localStorage.setItem('theme', theme); },
diff --git a/src/MaIN.InferPage/Components/Layout/MainLayout.razor b/src/MaIN.InferPage/Components/Layout/MainLayout.razor
index b0f6917a..d0477f15 100644
--- a/src/MaIN.InferPage/Components/Layout/MainLayout.razor
+++ b/src/MaIN.InferPage/Components/Layout/MainLayout.razor
@@ -1,4 +1,4 @@
-@inherits LayoutComponentBase
+@inherits LayoutComponentBase
 <NavBar/>
 <div class="content">
 
@@ -9,4 +9,4 @@
     An unhandled error has occurred.
     <a href="." class="reload">Reload</a>
     <span class="dismiss">🗙</span>
-</div>
+</div>
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Components/Layout/NavBar.razor b/src/MaIN.InferPage/Components/Layout/NavBar.razor
index 752cfe74..46ff6e78 100644
--- a/src/MaIN.InferPage/Components/Layout/NavBar.razor
+++ b/src/MaIN.InferPage/Components/Layout/NavBar.razor
@@ -1,7 +1,10 @@
 @using Microsoft.FluentUI.AspNetCore.Components.Icons.Regular
 @using MaIN.Domain.Configuration
+@using MaIN.InferPage.Services
 @inject NavigationManager _navigationManager
 @inject IJSRuntime JS
+@inject SettingsStateService SettingsState
+@implements IDisposable
 @rendermode @(new InteractiveServerRenderMode(prerender: false))
 
 <FluentDesignTheme @bind-Mode="@Mode"
@@ -48,6 +51,11 @@
             Style="margin-left: 10px">Vision 👁️</FluentBadge>
     }
     <div  style="margin-left: auto; align-self: flex-end;">
+        <FluentButton Style="background-color: transparent;"
+                      BackgroundColor="rgba(0, 0, 0, 0)"
+                      Appearance="Appearance.Lightweight"
+                      OnClick="@OpenSettings" IconStart="@(new Icons.Regular.Size24.Settings().WithColor(AccentColor))">
+        </FluentButton>
         <FluentButton Style="padding: 10px; background-color: transparent;"
                       BackgroundColor="rgba(0, 0, 0, 0)"
                       Appearance="Appearance.Lightweight"
@@ -72,10 +80,16 @@
         {
             var stored = await JS.InvokeAsync<string>("themeManager.load");
             Mode = stored == "dark" ? DesignThemeModes.Dark : DesignThemeModes.Light;
+            SettingsState.OnSettingsApplied += OnSettingsChanged;
             StateHasChanged();
         }
     }
 
+    private void OnSettingsChanged()
+    {
+        InvokeAsync(StateHasChanged);
+    }
+
     private void SetTheme()
     {
         if (_isChangingTheme) return;
@@ -89,6 +103,11 @@
         _navigationManager.Refresh(true);
     }
 
+    private void OpenSettings()
+    {
+        SettingsState.RequestSettings();
+    }
+
     private string GetBackendColor()
     {
         return Utils.IsLocal ? "#6b7280" : "#10a37f";
@@ -103,4 +122,9 @@
             _ => Utils.BackendType.ToString()
         };
     }
+
+    public void Dispose()
+    {
+        SettingsState.OnSettingsApplied -= OnSettingsChanged;
+    }
 }
diff --git a/src/MaIN.InferPage/Components/Pages/Home.razor b/src/MaIN.InferPage/Components/Pages/Home.razor
index dd8bb757..e11860ea 100644
--- a/src/MaIN.InferPage/Components/Pages/Home.razor
+++ b/src/MaIN.InferPage/Components/Pages/Home.razor
@@ -1,6 +1,9 @@
 @page "/"
 @rendermode @(new InteractiveServerRenderMode(prerender: true))
 @inject IJSRuntime JS
+@inject SettingsService SettingsStorage
+@inject SettingsStateService SettingsState
+@inject MaIN.Domain.Configuration.MaINSettings MaINSettings
 @implements IDisposable
 @using MaIN.Core.Hub
 @using MaIN.Core.Hub.Contexts.Interfaces.ChatContext
@@ -18,6 +21,13 @@
 
 <ErrorNotification @bind-ErrorMessage="_errorMessage" />
 
+@if (_showSettings)
+{
+    <Settings ShowCloseButton="@_hasExistingConfig"
+              OnSettingsApplied="@HandleSettingsApplied"
+              OnClose="@HideSettings" />
+}
+
 <div class="chat-container" id="chat-container">
     @if (_isDragging)
     {
@@ -204,6 +214,8 @@
 </div>
 
 @code {
+    private bool _showSettings;
+    private bool _hasExistingConfig;
     private bool _isLoading;
     private bool _isThinking;
     private bool _isDragging;
@@ -214,7 +226,7 @@
     private string? _incomingReasoning;
     private IChatMessageBuilder? ctx;
     private CancellationTokenSource? _cancellationTokenSource;
-    private Chat Chat { get; } = new() { Name = "MaIN Infer", ModelId = Utils.Model! };
+    private Chat Chat { get; set; } = new() { Name = "MaIN Infer", ModelId = Utils.Model ?? "unknown" };
     private List<MessageExt> Messages { get; set; } = new();
     private ElementReference? _bottomElement;
     private ElementReference _editorRef;
@@ -243,6 +255,30 @@
             await JS.InvokeVoidAsync("editorManager.attachPasteHandler", _editorRef, _dotNetRef);
             await JS.InvokeVoidAsync("editorManager.attachDropZone", "chat-container", _dotNetRef);
 
+            // Settings initialization (requires JS interop, so must be in OnAfterRenderAsync)
+            SettingsState.OnSettingsRequested += ShowSettingsFromGear;
+
+            if (Utils.NeedsConfiguration)
+            {
+                var hasBrowserSettings = await SettingsStorage.HasSettingsAsync();
+                if (hasBrowserSettings)
+                {
+                    await LoadAndApplyBrowserSettings();
+                    _hasExistingConfig = true;
+                    InitializeChatContext();
+                    SettingsState.NotifySettingsApplied();
+                }
+                else
+                {
+                    _showSettings = true;
+                    _hasExistingConfig = false;
+                }
+            }
+            else
+            {
+                _hasExistingConfig = true;
+            }
+
             StateHasChanged();
         }
         else if (_preserveScroll)
@@ -254,24 +290,28 @@
 
     protected override Task OnInitializedAsync()
     {
-        AIModel? model = null;
+        // Only init chat if CLI args provided (no browser settings needed)
+        if (!Utils.NeedsConfiguration && !string.IsNullOrEmpty(Utils.Model))
+        {
+            InitializeChatContext();
+        }
 
+        return base.OnInitializedAsync();
+    }
+
+    private void InitializeChatContext()
+    {
         try
         {
-            if (Utils.BackendType == BackendType.Self && Utils.Path != null)
+            var model = ResolveModel();
+            if (model != null)
             {
-                model = ModelRegistry.TryGetById(Utils.Model!, out var foundModel1)
-                    ? foundModel1!
-                    : new GenericLocalModel($"{Utils.Model}.gguf");
+                var newCtx = AIHub.Chat().WithModel(model, imageGen: Utils.ImageGen);
+                // Preserve history on model switch; cast is safe — ChatContext implements both interfaces.
+                ctx = Chat.Messages.Count > 0
+                    ? (IChatMessageBuilder)newCtx.WithMessages(Chat.Messages)
+                    : newCtx;
             }
-            else
-            {
-                model = ModelRegistry.TryGetById(Utils.Model!, out var foundModel1)
-                    ? foundModel1!
-                    : new GenericCloudModel(Id: Utils.Model!, Backend: Utils.BackendType);
-            }
-
-            ctx = AIHub.Chat().WithModel(model, imageGen: Utils.ImageGen);
         }
         catch (MaINCustomException ex)
         {
@@ -281,8 +321,103 @@
         {
             _errorMessage = ex.Message;
         }
+    }
 
-        return base.OnInitializedAsync();
+    private AIModel? ResolveModel()
+    {
+        if (string.IsNullOrEmpty(Utils.Model)) return null;
+
+        if (ModelRegistry.TryGetById(Utils.Model, out var registeredModel))
+            return registeredModel;
+
+        // Self = local GGUF file; Ollama Local is an HTTP server, not a file path
+        if (Utils.BackendType == BackendType.Self)
+        {
+            string modelFileName;
+            if (!string.IsNullOrEmpty(Utils.Path))
+            {
+                modelFileName = Utils.Path.EndsWith(".gguf", StringComparison.OrdinalIgnoreCase)
+                    ? Utils.Path
+                    : System.IO.Path.Combine(Utils.Path, $"{Utils.Model.Replace(':', '-')}.gguf");
+            }
+            else
+            {
+                modelFileName = $"{Utils.Model.Replace(':', '-')}.gguf";
+            }
+            return new GenericLocalModel(FileName: modelFileName);
+        }
+
+        // Cloud model — pick the right generic type based on capabilities
+        bool vision = Utils.Vision;
+        bool reasoning = Utils.Reason;
+
+        if (vision && reasoning)
+            return new GenericCloudVisionReasoningModel(Id: Utils.Model, Backend: Utils.BackendType);
+        if (vision)
+            return new GenericCloudVisionModel(Id: Utils.Model, Backend: Utils.BackendType);
+        if (reasoning)
+            return new GenericCloudReasoningModel(Id: Utils.Model, Backend: Utils.BackendType);
+
+        return new GenericCloudModel(Id: Utils.Model, Backend: Utils.BackendType);
+    }
+
+    private void ReinitializeChat()
+    {
+        if (string.IsNullOrEmpty(Utils.Model)) return;
+
+        _errorMessage = null;
+        Chat.ModelId = Utils.Model;
+        Chat.ImageGen = Utils.ImageGen;
+        InitializeChatContext();
+        StateHasChanged();
+    }
+
+    private async Task LoadAndApplyBrowserSettings()
+    {
+        var settings = await SettingsStorage.LoadSettingsAsync();
+        if (settings == null) return;
+
+        var backendType = (BackendType)settings.BackendType;
+
+        string? apiKey = null;
+        if (backendType != BackendType.Self)
+        {
+            var backendKey = backendType == BackendType.Ollama
+                ? (settings.IsOllamaCloud ? "OllamaCloud" : "OllamaLocal")
+                : backendType.ToString();
+
+            apiKey = await SettingsStorage.GetApiKeyForBackendAsync(backendKey);
+        }
+
+        Utils.ApplySettings(
+            backendType,
+            settings.Model!,
+            settings.ModelPath,
+            settings.HasVision,
+            settings.HasReasoning,
+            settings.HasImageGen,
+            MaINSettings,
+            apiKey);
+    }
+
+    private void ShowSettingsFromGear()
+    {
+        _showSettings = true;
+        InvokeAsync(StateHasChanged);
+    }
+
+    private void HandleSettingsApplied()
+    {
+        _hasExistingConfig = true;
+        _showSettings = false;
+        ReinitializeChat();
+        SettingsState.NotifySettingsApplied();
+    }
+
+    private void HideSettings()
+    {
+        _showSettings = false;
+        StateHasChanged();
     }
 
     private async Task HandleKeyDown(KeyboardEventArgs e)
@@ -635,6 +770,7 @@
 
     public void Dispose()
     {
+        SettingsState.OnSettingsRequested -= ShowSettingsFromGear;
         _cancellationTokenSource?.Dispose();
         _dotNetRef?.Dispose();
     }
diff --git a/src/MaIN.InferPage/Components/Pages/Settings.razor b/src/MaIN.InferPage/Components/Pages/Settings.razor
new file mode 100644
index 00000000..f3f22942
--- /dev/null
+++ b/src/MaIN.InferPage/Components/Pages/Settings.razor
@@ -0,0 +1,422 @@
+@using MaIN.Domain.Configuration
+@using MaIN.Domain.Models.Abstract
+@inject SettingsService SettingsStorage
+@inject MaINSettings MaINSettings
+@rendermode @(new InteractiveServerRenderMode(prerender: false))
+
+<link rel="stylesheet" href="settings.css">
+
+<div class="settings-overlay">
+    <div class="settings-panel">
+        <div class="settings-header">
+            <h2>Settings</h2>
+            @if (ShowCloseButton)
+            {
+                <FluentButton Appearance="Appearance.Lightweight"
+                              Style="--neutral-fill-stealth-rest: transparent; --neutral-fill-stealth-hover: rgba(128,128,128,0.15); --neutral-fill-stealth-active: rgba(128,128,128,0.25);"
+                              OnClick="@OnClose"
+                              IconStart="@(new Icons.Regular.Size24.Dismiss())">
+                </FluentButton>
+            }
+        </div>
+
+        <div class="settings-body">
+            <div class="settings-field">
+                <label class="settings-label">Backend</label>
+                <FluentSelect TOption="BackendOption"
+                              Items="@_backendOptions"
+                              OptionValue="@(o => o.Id.ToString())"
+                              OptionText="@(o => o.DisplayName)"
+                              @bind-SelectedOption="_selectedBackend"
+                              @bind-SelectedOption:after="OnBackendChanged"
+                              Style="width: 100%;" />
+            </div>
+
+            <div class="settings-field">
+                <label class="settings-label">Model</label>
+                <FluentTextField @bind-Value="_modelName"
+                                 @bind-Value:after="OnModelNameChanged"
+                                 Placeholder="e.g., gpt-4o, gemma3-4b"
+                                 Style="width: 100%;" />
+            </div>
+
+            @if (RequiresApiKey)
+            {
+                <div class="settings-field">
+                    <label class="settings-label">API Key</label>
+                    <div class="api-key-row">
+                        <FluentTextField @bind-Value="_apiKeyInput"
+                                         Placeholder="Enter API key"
+                                         TextFieldType="@(_showApiKey ? TextFieldType.Text : TextFieldType.Password)"
+                                         Style="flex: 1;" />
+                        <FluentButton Appearance="Appearance.Lightweight"
+                                      Style="--neutral-fill-stealth-rest: transparent; --neutral-fill-stealth-hover: rgba(128,128,128,0.15); --neutral-fill-stealth-active: rgba(128,128,128,0.25);"
+                                      OnClick="@ToggleApiKeyVisibility"
+                                      IconStart="@(_showApiKey
+                                          ? new Icons.Regular.Size20.EyeOff()
+                                          : (Icon)new Icons.Regular.Size20.Eye())">
+                        </FluentButton>
+                    </div>
+                    @if (!string.IsNullOrEmpty(_savedKeyPreview))
+                    {
+                        <span class="api-key-hint">Saved: @_savedKeyPreview</span>
+                    }
+                </div>
+            }
+
+            @if (_selectedBackend?.BackendType == BackendType.Self)
+            {
+                <div class="settings-field">
+                    <label class="settings-label">Model Path</label>
+                    <FluentTextField @bind-Value="_modelPath"
+                                     Placeholder="Optional: model.gguf, C:\dir\model.gguf, or C:\dir"
+                                     Style="width: 100%;" />
+                    @if (ResolvedModelPathPreview is { } preview)
+                    {
+                        <span class="api-key-hint">Will load: @preview</span>
+                    }
+                </div>
+            }
+
+            @if (!string.IsNullOrWhiteSpace(_modelName))
+            {
+                <div class="settings-field">
+                    @if (_isRegisteredModel)
+                    {
+                        <label class="settings-label">Detected Capabilities</label>
+                        <div class="capabilities-row">
+                            @if (_detectedVision)
+                            {
+                                <FluentBadge BackgroundColor="#0ea5e9" Color="#fff">Vision</FluentBadge>
+                            }
+                            @if (_detectedReasoning)
+                            {
+                                <FluentBadge BackgroundColor="#ffd800" Color="#000">Reasoning</FluentBadge>
+                            }
+                            @if (_detectedImageGen)
+                            {
+                                <FluentBadge BackgroundColor="#7c3aed" Color="#fff">Image Gen</FluentBadge>
+                            }
+                            @if (!_detectedVision && !_detectedReasoning && !_detectedImageGen)
+                            {
+                                <span class="no-capabilities">No special capabilities</span>
+                            }
+                        </div>
+                    }
+                    else
+                    {
+                        <label class="settings-label">Model Capabilities</label>
+                        <span class="capabilities-hint">Model not in registry. Select supported capabilities:</span>
+                        <div class="capabilities-checkboxes">
+                            <FluentCheckbox @bind-Value="_manualVision" Label="Vision" />
+                            <FluentCheckbox @bind-Value="_manualReasoning" Label="Reasoning" />
+                            <FluentCheckbox @bind-Value="_manualImageGen" Label="Image Generation" />
+                        </div>
+                    }
+                </div>
+            }
+        </div>
+
+        <div class="settings-footer">
+            <FluentButton Appearance="Appearance.Accent"
+                          OnClick="@SaveAndApply"
+                          Disabled="@(!CanSave)">
+                @(ShowCloseButton ? "Save & Apply" : "Get Started")
+            </FluentButton>
+        </div>
+    </div>
+</div>
+
+@code {
+    [Parameter] public bool ShowCloseButton { get; set; }
+    [Parameter] public EventCallback OnSettingsApplied { get; set; }
+    [Parameter] public EventCallback OnClose { get; set; }
+
+    private List<BackendOption> _backendOptions = null!;
+    private BackendOption? _selectedBackend;
+    private string? _modelName;
+    private string? _modelPath;
+    private string? _apiKeyInput;
+    private string? _savedKeyPreview;
+    private bool _showApiKey;
+
+    // "Will load:" path preview shown below the model path field (Self backend only)
+    private string? ResolvedModelPathPreview
+    {
+        get
+        {
+            if (_selectedBackend?.BackendType != BackendType.Self) return null;
+            if (string.IsNullOrWhiteSpace(_modelName)) return null;
+
+            // Mirror Utils.ApplySettings sanitization (strips U+202A and other format chars)
+            var rawPath = _modelPath?.Trim() ?? "";
+            int i = 0;
+            while (i < rawPath.Length && (char.IsControl(rawPath[i]) || char.GetUnicodeCategory(rawPath[i]) == System.Globalization.UnicodeCategory.Format))
+            {
+                i++;
+            }
+
+            var cleanPath = i < rawPath.Length ? rawPath.Substring(i) : "";
+            var sanitizedModel = $"{_modelName.Trim().Replace(':', '-')}.gguf";
+
+            string fileName;
+            if (!string.IsNullOrEmpty(cleanPath))
+            {
+                fileName = cleanPath.EndsWith(".gguf", StringComparison.OrdinalIgnoreCase)
+                    ? cleanPath
+                    : Path.Combine(cleanPath, sanitizedModel);
+            }
+            else
+            {
+                fileName = sanitizedModel;
+            }
+
+            // Relative path: prepend configured models directory
+            if (!Path.IsPathFullyQualified(fileName))
+            {
+                var modelsDir = MaINSettings.ModelsPath
+                    ?? Environment.GetEnvironmentVariable("MaIN_ModelsPath");
+                if (!string.IsNullOrEmpty(modelsDir))
+                    fileName = Path.Combine(modelsDir, fileName);
+            }
+
+            return fileName;
+        }
+    }
+
+    // Registered model detection
+    private bool _isRegisteredModel;
+    private bool _detectedVision;
+    private bool _detectedReasoning;
+    private bool _detectedImageGen;
+
+    // Manual capability selection (unregistered models)
+    private bool _manualVision;
+    private bool _manualReasoning;
+    private bool _manualImageGen;
+
+    private bool RequiresApiKey => _selectedBackend?.RequiresApiKey == true;
+    private bool CanSave => !string.IsNullOrWhiteSpace(_modelName)
+                            && _selectedBackend != null
+                            && (!RequiresApiKey || !string.IsNullOrEmpty(_apiKeyInput) || !string.IsNullOrEmpty(_savedKeyPreview));
+
+    protected override async Task OnInitializedAsync()
+    {
+        var localOption = new BackendOption(0, "Local", BackendType.Self, false);
+
+        var backendOptions = new List<BackendOption>
+        {
+            new(1, "OpenAI", BackendType.OpenAi, true),
+            new(2, "Gemini", BackendType.Gemini, true),
+            new(3, "DeepSeek", BackendType.DeepSeek, true),
+            new(4, "GroqCloud", BackendType.GroqCloud, true),
+            new(5, "Anthropic", BackendType.Anthropic, true),
+            new(6, "xAI", BackendType.Xai, true),
+            new(7, "Ollama (Local)", BackendType.Ollama, false),
+            new(8, "Ollama (Cloud)", BackendType.Ollama, true)
+
+        }.OrderBy(x => x.DisplayName).ToList();
+
+        backendOptions.Insert(0, localOption);
+        _backendOptions = backendOptions;
+
+        await base.OnInitializedAsync();
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await LoadCurrentSettings();
+            StateHasChanged();
+        }
+    }
+
+    private async Task LoadCurrentSettings()
+    {
+        var settings = await SettingsStorage.LoadSettingsAsync();
+        if (settings != null)
+        {
+            var backendType = (BackendType)settings.BackendType;
+
+            if (backendType == BackendType.Ollama)
+            {
+                _selectedBackend = settings.IsOllamaCloud
+                    ? _backendOptions.First(o => o.Id == 8)
+                    : _backendOptions.First(o => o.Id == 7);
+            }
+            else
+            {
+                _selectedBackend = _backendOptions.FirstOrDefault(o => o.BackendType == backendType && o.Id < 7);
+            }
+
+            _modelName = settings.Model;
+            _modelPath = settings.ModelPath;
+            _manualVision = settings.HasVision;
+            _manualReasoning = settings.HasReasoning;
+            _manualImageGen = settings.HasImageGen;
+
+            OnModelNameChanged();
+        }
+        else if (!Utils.NeedsConfiguration)
+        {
+            // Load from current Utils state (CLI-configured)
+            _selectedBackend = Utils.BackendType == BackendType.Ollama
+                ? (Utils.HasApiKey
+                    ? _backendOptions.First(o => o.Id == 8)
+                    : _backendOptions.First(o => o.Id == 7))
+                : _backendOptions.FirstOrDefault(o => o.BackendType == Utils.BackendType && o.Id < 7);
+
+            _modelName = Utils.Model;
+            _modelPath = Utils.Path;
+
+            OnModelNameChanged();
+        }
+
+        if (_selectedBackend != null)
+            await LoadApiKeyPreview();
+    }
+
+    private async Task OnBackendChanged()
+    {
+        if (_selectedBackend == null) return;
+
+        var backendKey = GetBackendStorageKey();
+        var lastModel = await SettingsStorage.GetLastModelForBackendAsync(backendKey);
+        if (!string.IsNullOrEmpty(lastModel))
+        {
+            _modelName = lastModel;
+            OnModelNameChanged();
+        }
+
+        await LoadApiKeyPreview();
+        _apiKeyInput = null;
+    }
+
+    private void OnModelNameChanged()
+    {
+        if (string.IsNullOrWhiteSpace(_modelName))
+        {
+            _isRegisteredModel = false;
+            return;
+        }
+
+        _isRegisteredModel = ModelRegistry.TryGetById(_modelName, out var model);
+        if (_isRegisteredModel && model != null)
+        {
+            _detectedVision = model is IVisionModel;
+            _detectedReasoning = model is IReasoningModel;
+            _detectedImageGen = model is IImageGenerationModel;
+        }
+        else
+        {
+            _detectedVision = false;
+            _detectedReasoning = false;
+            _detectedImageGen = false;
+
+            // Pre-check known models from fallback lists
+            if (Utils.IsKnownVisionModel(_modelName)) _manualVision = true;
+            if (Utils.IsKnownImageGenModel(_modelName)) _manualImageGen = true;
+        }
+    }
+
+    private async Task LoadApiKeyPreview()
+    {
+        if (_selectedBackend == null || !_selectedBackend.RequiresApiKey)
+        {
+            _savedKeyPreview = null;
+            return;
+        }
+
+        var backendKey = GetBackendStorageKey();
+        var savedKey = await SettingsStorage.GetApiKeyForBackendAsync(backendKey);
+
+        _savedKeyPreview = string.IsNullOrEmpty(savedKey)
+            ? null
+            : MaskApiKey(savedKey);
+    }
+
+    private void ToggleApiKeyVisibility()
+    {
+        _showApiKey = !_showApiKey;
+    }
+
+    private async Task SaveAndApply()
+    {
+        if (_selectedBackend == null || string.IsNullOrWhiteSpace(_modelName)) return;
+
+        var backendKey = GetBackendStorageKey();
+        var isOllamaCloud = _selectedBackend.Id == 8;
+
+        bool hasVision, hasReasoning, hasImageGen;
+        if (_isRegisteredModel)
+        {
+            hasVision = _detectedVision;
+            hasReasoning = _detectedReasoning;
+            hasImageGen = _detectedImageGen;
+        }
+        else
+        {
+            hasVision = _manualVision;
+            hasReasoning = _manualReasoning;
+            hasImageGen = _manualImageGen;
+        }
+
+        var settings = new InferPageSettings
+        {
+            BackendType = (int)_selectedBackend.BackendType,
+            IsOllamaCloud = isOllamaCloud,
+            Model = _modelName,
+            HasVision = hasVision,
+            HasReasoning = hasReasoning,
+            HasImageGen = hasImageGen,
+            ModelPath = _modelPath
+        };
+        await SettingsStorage.SaveSettingsAsync(settings);
+
+        await SettingsStorage.SaveModelForBackendAsync(backendKey, _modelName);
+
+        // Resolve API key: use new input, or fall back to saved key
+        string? apiKey = null;
+        if (RequiresApiKey)
+        {
+            if (!string.IsNullOrWhiteSpace(_apiKeyInput))
+            {
+                apiKey = _apiKeyInput;
+                await SettingsStorage.SaveApiKeyAsync(backendKey, apiKey);
+            }
+            else
+            {
+                apiKey = await SettingsStorage.GetApiKeyForBackendAsync(backendKey);
+            }
+        }
+
+        Utils.ApplySettings(
+            _selectedBackend.BackendType,
+            _modelName,
+            _modelPath,
+            hasVision,
+            hasReasoning,
+            hasImageGen,
+            MaINSettings,
+            apiKey);
+
+        await OnSettingsApplied.InvokeAsync();
+    }
+
+    private string GetBackendStorageKey()
+    {
+        if (_selectedBackend == null) return "Self";
+        if (_selectedBackend.Id == 7) return "OllamaLocal";
+        if (_selectedBackend.Id == 8) return "OllamaCloud";
+        return _selectedBackend.BackendType.ToString();
+    }
+
+    private static string MaskApiKey(string key)
+    {
+        if (key.Length <= 12) return key;
+        return key[..6] + "..." + key[^6..];
+    }
+
+    public record BackendOption(int Id, string DisplayName, BackendType BackendType, bool RequiresApiKey);
+}
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Components/_Imports.razor b/src/MaIN.InferPage/Components/_Imports.razor
index a7b02a1b..02a2abe5 100644
--- a/src/MaIN.InferPage/Components/_Imports.razor
+++ b/src/MaIN.InferPage/Components/_Imports.razor
@@ -9,4 +9,6 @@
 @using Icons = Microsoft.FluentUI.AspNetCore.Components.Icons
 @using Microsoft.JSInterop
 @using MaIN.InferPage
-@using MaIN.InferPage.Components
\ No newline at end of file
+@using MaIN.InferPage.Components
+@using MaIN.InferPage.Components.Pages
+@using MaIN.InferPage.Services
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Program.cs b/src/MaIN.InferPage/Program.cs
index 581e0b7b..6303b27e 100644
--- a/src/MaIN.InferPage/Program.cs
+++ b/src/MaIN.InferPage/Program.cs
@@ -2,6 +2,7 @@
 using MaIN.Domain.Configuration;
 using MaIN.Domain.Models.Concrete;
 using MaIN.Domain.Models.Abstract;
+using MaIN.InferPage.Services;
 using Microsoft.FluentUI.AspNetCore.Components;
 using MaIN.InferPage.Components;
 using Utils = MaIN.InferPage.Utils;
@@ -14,6 +15,8 @@
         options.MaximumReceiveMessageSize = 10 * 1024 * 1024; // 10 MB
     });
 builder.Services.AddFluentUIComponents();
+builder.Services.AddScoped<SettingsService>();
+builder.Services.AddScoped<SettingsStateService>();
 
 try
 {
@@ -21,65 +24,74 @@
     var modelPathArg = builder.Configuration["path"];
     var backendArg = builder.Configuration["backend"];
 
+    bool hasCommandLineConfig = backendArg != null || modelArg != null;
 
-    if (backendArg != null)
+    if (hasCommandLineConfig)
     {
-        Utils.BackendType = backendArg.ToLower() switch
+        if (backendArg != null)
         {
-            "openai" => BackendType.OpenAi,
-            "gemini" => BackendType.Gemini,
-            "deepseek" => BackendType.DeepSeek,
-            "groqcloud" => BackendType.GroqCloud,
-            "anthropic" => BackendType.Anthropic,
-            "xai" => BackendType.Xai,
-            "ollama" => BackendType.Ollama,
-            _ => BackendType.Self
-        };
-
-        if (Utils.BackendType != BackendType.Self)
-        {
-            var apiKeyVariable = LLMApiRegistry.GetEntry(Utils.BackendType)?.ApiKeyEnvName ?? string.Empty;
-            var key = Environment.GetEnvironmentVariable(apiKeyVariable);
-
-            if (string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(apiKeyVariable))
+            Utils.BackendType = backendArg.ToLower() switch
+            {
+                "openai" => BackendType.OpenAi,
+                "gemini" => BackendType.Gemini,
+                "deepseek" => BackendType.DeepSeek,
+                "groqcloud" => BackendType.GroqCloud,
+                "anthropic" => BackendType.Anthropic,
+                "xai" => BackendType.Xai,
+                "ollama" => BackendType.Ollama,
+                _ => BackendType.Self
+            };
+
+            if (Utils.BackendType != BackendType.Self)
             {
-                Console.Write($"Please enter your {Utils.BackendType.ToString()} API key: ");
-                key = Console.ReadLine();
+                var apiKeyVariable = LLMApiRegistry.GetEntry(Utils.BackendType)?.ApiKeyEnvName ?? string.Empty;
+                var key = Environment.GetEnvironmentVariable(apiKeyVariable);
 
-                if (!string.IsNullOrWhiteSpace(key))
+                if (string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(apiKeyVariable))
                 {
-                    Utils.HasApiKey = true;
-                    Environment.SetEnvironmentVariable(apiKeyVariable, key);
+                    Console.Write($"Please enter your {Utils.BackendType.ToString()} API key: ");
+                    key = Console.ReadLine();
+
+                    if (!string.IsNullOrWhiteSpace(key))
+                    {
+                        Utils.HasApiKey = true;
+                        Environment.SetEnvironmentVariable(apiKeyVariable, key);
+                    }
                 }
             }
         }
-    }
 
-    if (!string.IsNullOrEmpty(modelArg))
-    {
-        Utils.Model = modelArg;
-        Utils.Path = modelPathArg;
-
-        if (Utils.BackendType == BackendType.Self)
+        if (!string.IsNullOrEmpty(modelArg))
         {
-            if (string.IsNullOrEmpty(modelPathArg))
-            {
-                Console.WriteLine("Error: A model path must be provided using --path when a local model is specified.");
-                return;
-            }
+            Utils.Model = modelArg;
+            Utils.Path = modelPathArg;
 
-            var envModelsPath = Environment.GetEnvironmentVariable("MaIN_ModelsPath");
-            if (string.IsNullOrEmpty(envModelsPath))
+            if (Utils.BackendType == BackendType.Self)
             {
-                Console.Write("Please enter the MaIN_ModelsPath: ");
-                envModelsPath = Console.ReadLine();
-                Environment.SetEnvironmentVariable("MaIN_ModelsPath", envModelsPath);
+                if (string.IsNullOrEmpty(modelPathArg))
+                {
+                    Console.WriteLine("Error: A model path must be provided using --path when a local model is specified.");
+                    return;
+                }
+
+                var envModelsPath = Environment.GetEnvironmentVariable("MaIN_ModelsPath");
+                if (string.IsNullOrEmpty(envModelsPath))
+                {
+                    Console.Write("Please enter the MaIN_ModelsPath: ");
+                    envModelsPath = Console.ReadLine();
+                    Environment.SetEnvironmentVariable("MaIN_ModelsPath", envModelsPath);
+                }
             }
         }
+        else
+        {
+            Console.WriteLine("No model argument provided. Continuing without model configuration.");
+        }
     }
     else
     {
-        Console.WriteLine("No model argument provided. Continuing without model configuration.");
+        // No CLI args — settings will be loaded from browser localStorage
+        Utils.NeedsConfiguration = true;
     }
 }
 catch (Exception ex)
@@ -88,7 +100,12 @@
     return;
 }
 
-if (Utils.BackendType != BackendType.Self)
+if (Utils.NeedsConfiguration)
+{
+    // Register with defaults — will be reconfigured at runtime via Settings UI
+    builder.Services.AddMaIN(builder.Configuration);
+}
+else if (Utils.BackendType != BackendType.Self)
 {
     builder.Services.AddMaIN(builder.Configuration, settings =>
     {
@@ -122,4 +139,4 @@
 app.MapRazorComponents<App>()
     .AddInteractiveServerRenderMode();
 
-app.Run();
+app.Run();
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Services/InferPageSettings.cs b/src/MaIN.InferPage/Services/InferPageSettings.cs
new file mode 100644
index 00000000..ec66cbc2
--- /dev/null
+++ b/src/MaIN.InferPage/Services/InferPageSettings.cs
@@ -0,0 +1,12 @@
+namespace MaIN.InferPage.Services;
+
+public class InferPageSettings
+{
+    public int BackendType { get; set; }
+    public bool IsOllamaCloud { get; set; }
+    public string? Model { get; set; }
+    public bool HasVision { get; set; }
+    public bool HasReasoning { get; set; }
+    public bool HasImageGen { get; set; }
+    public string? ModelPath { get; set; }
+}
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Services/SettingsService.cs b/src/MaIN.InferPage/Services/SettingsService.cs
new file mode 100644
index 00000000..07144e54
--- /dev/null
+++ b/src/MaIN.InferPage/Services/SettingsService.cs
@@ -0,0 +1,68 @@
+using Microsoft.JSInterop;
+
+namespace MaIN.InferPage.Services;
+
+public class SettingsService
+{
+    private const string SettingsKey = "inferpage-settings";
+    private const string ApiKeysKey = "inferpage-apikeys";
+    private const string ModelHistoryKey = "inferpage-model-history";
+
+    private readonly IJSRuntime _js;
+
+    public SettingsService(IJSRuntime js)
+    {
+        _js = js;
+    }
+
+    public async Task<InferPageSettings?> LoadSettingsAsync()
+    {
+        return await _js.InvokeAsync<InferPageSettings?>("settingsManager.load", SettingsKey);
+    }
+
+    public async Task SaveSettingsAsync(InferPageSettings settings)
+    {
+        await _js.InvokeVoidAsync("settingsManager.save", SettingsKey, settings);
+    }
+
+    public async Task<bool> HasSettingsAsync()
+    {
+        return await _js.InvokeAsync<bool>("settingsManager.exists", SettingsKey);
+    }
+
+    public async Task<Dictionary<string, string>?> LoadApiKeysAsync()
+    {
+        return await _js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", ApiKeysKey);
+    }
+
+    public async Task SaveApiKeyAsync(string backendName, string key)
+    {
+        var keys = await LoadApiKeysAsync() ?? new Dictionary<string, string>();
+        keys[backendName] = key;
+        await _js.InvokeVoidAsync("settingsManager.save", ApiKeysKey, keys);
+    }
+
+    public async Task<string?> GetApiKeyForBackendAsync(string backendName)
+    {
+        var keys = await LoadApiKeysAsync();
+        return keys?.GetValueOrDefault(backendName);
+    }
+
+    public async Task<Dictionary<string, string>?> LoadModelHistoryAsync()
+    {
+        return await _js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", ModelHistoryKey);
+    }
+
+    public async Task SaveModelForBackendAsync(string backendName, string model)
+    {
+        var history = await LoadModelHistoryAsync() ?? new Dictionary<string, string>();
+        history[backendName] = model;
+        await _js.InvokeVoidAsync("settingsManager.save", ModelHistoryKey, history);
+    }
+
+    public async Task<string?> GetLastModelForBackendAsync(string backendName)
+    {
+        var history = await LoadModelHistoryAsync();
+        return history?.GetValueOrDefault(backendName);
+    }
+}
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Services/SettingsStateService.cs b/src/MaIN.InferPage/Services/SettingsStateService.cs
new file mode 100644
index 00000000..1aef52b6
--- /dev/null
+++ b/src/MaIN.InferPage/Services/SettingsStateService.cs
@@ -0,0 +1,21 @@
+namespace MaIN.InferPage.Services;
+
+/// <summary>
+/// Scoped service for cross-component settings event communication.
+/// NavBar (interactive) fires events, Home (interactive) subscribes.
+/// </summary>
+public class SettingsStateService
+{
+    public event Action? OnSettingsRequested;
+    public event Action? OnSettingsApplied;
+
+    public void RequestSettings()
+    {
+        OnSettingsRequested?.Invoke();
+    }
+
+    public void NotifySettingsApplied()
+    {
+        OnSettingsApplied?.Invoke();
+    }
+}
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Utils.cs b/src/MaIN.InferPage/Utils.cs
index a4fc2872..1a927625 100644
--- a/src/MaIN.InferPage/Utils.cs
+++ b/src/MaIN.InferPage/Utils.cs
@@ -1,6 +1,7 @@
 using MaIN.Domain.Configuration;
 using MaIN.Domain.Entities;
 using MaIN.Domain.Models.Abstract;
+using MaIN.Domain.Models.Concrete;
 
 namespace MaIN.InferPage;
 
@@ -11,6 +12,13 @@ public static class Utils
     public static string? Path { get; set; }
     public static bool IsLocal => BackendType == BackendType.Self || (BackendType == BackendType.Ollama && !HasApiKey);
     public static string? Model = "gemma3-4b";
+    public static bool NeedsConfiguration { get; set; }
+
+    // Manual capability overrides for unregistered models (set from Settings UI)
+    public static bool? ManualVision { get; set; }
+    public static bool? ManualReasoning { get; set; }
+    public static bool? ManualImageGen { get; set; }
+
     public static bool Reason
     {
         get
@@ -18,6 +26,7 @@ public static bool Reason
             if (string.IsNullOrEmpty(Model)) return false;
             if (ModelRegistry.TryGetById(Model, out var m))
                 return m is IReasoningModel && !ImageGen; // reasoning and image gen are mutually exclusive
+            if (ManualReasoning.HasValue) return ManualReasoning.Value;
             return false;
         }
     }
@@ -29,6 +38,7 @@ public static bool ImageGen
             if (string.IsNullOrEmpty(Model)) return false;
             if (ModelRegistry.TryGetById(Model, out var m))
                 return m is IImageGenerationModel;
+            if (ManualImageGen.HasValue) return ManualImageGen.Value;
             return ImageGenerationModels.Contains(Model); // fallback for unregistered models (e.g. FLUX via separate server)
         }
     }
@@ -40,10 +50,92 @@ public static bool Vision
             if (string.IsNullOrEmpty(Model)) return false;
             if (ModelRegistry.TryGetById(Model, out var m))
                 return m is IVisionModel;
+            if (ManualVision.HasValue) return ManualVision.Value;
             return VisionModels.Contains(Model); // fallback for unregistered models
         }
     }
 
+    public static bool IsKnownVisionModel(string model) => VisionModels.Contains(model);
+    public static bool IsKnownImageGenModel(string model) => ImageGenerationModels.Contains(model);
+
+    public static void ApplySettings(
+        BackendType backendType,
+        string model,
+        string? modelPath,
+        bool hasVision,
+        bool hasReasoning,
+        bool hasImageGen,
+        MaINSettings mainSettings,
+        string? apiKey)
+    {
+        BackendType = backendType;
+        Model = model;
+        // Strip leading/trailing whitespace and invisible Unicode control/format characters
+        // (e.g. U+202A LEFT-TO-RIGHT EMBEDDING, U+FEFF BOM — added by Windows Explorer on copy-paste)
+        if (!string.IsNullOrWhiteSpace(modelPath))
+        {
+            var cleaned = modelPath.Trim();
+            int i = 0;
+            while (i < cleaned.Length &&
+                   (char.IsControl(cleaned[i]) ||
+                    char.GetUnicodeCategory(cleaned[i]) == System.Globalization.UnicodeCategory.Format))
+                i++;
+            Path = i < cleaned.Length ? cleaned.Substring(i) : null;
+        }
+        else
+        {
+            Path = null;
+        }
+        HasApiKey = !string.IsNullOrEmpty(apiKey);
+        NeedsConfiguration = false;
+
+        ManualVision = hasVision;
+        ManualReasoning = hasReasoning;
+        ManualImageGen = hasImageGen;
+
+        mainSettings.BackendType = backendType;
+
+        if (!string.IsNullOrEmpty(apiKey))
+        {
+            var entry = LLMApiRegistry.GetEntry(backendType);
+            if (entry != null)
+            {
+                Environment.SetEnvironmentVariable(entry.ApiKeyEnvName, apiKey);
+            }
+
+            switch (backendType)
+            {
+                case BackendType.OpenAi: mainSettings.OpenAiKey = apiKey; break;
+                case BackendType.Gemini: mainSettings.GeminiKey = apiKey; break;
+                case BackendType.DeepSeek: mainSettings.DeepSeekKey = apiKey; break;
+                case BackendType.Anthropic: mainSettings.AnthropicKey = apiKey; break;
+                case BackendType.GroqCloud: mainSettings.GroqCloudKey = apiKey; break;
+                case BackendType.Ollama: mainSettings.OllamaKey = apiKey; break;
+                case BackendType.Xai: mainSettings.XaiKey = apiKey; break;
+            }
+        }
+        else
+        {
+            // Clear stale key for this backend (e.g. switching Ollama Cloud → Local)
+            var entry = LLMApiRegistry.GetEntry(backendType);
+            if (entry != null)
+            {
+                Environment.SetEnvironmentVariable(entry.ApiKeyEnvName, null);
+            }
+
+            switch (backendType)
+            {
+                case BackendType.OpenAi: mainSettings.OpenAiKey = null; break;
+                case BackendType.Gemini: mainSettings.GeminiKey = null; break;
+                case BackendType.DeepSeek: mainSettings.DeepSeekKey = null; break;
+                case BackendType.Anthropic: mainSettings.AnthropicKey = null; break;
+                case BackendType.GroqCloud: mainSettings.GroqCloudKey = null; break;
+                case BackendType.Ollama: mainSettings.OllamaKey = null; break;
+                case BackendType.Xai: mainSettings.XaiKey = null; break;
+            }
+        }
+    }
+
     private static readonly HashSet<string> ImageGenerationModels =
     [
         "FLUX.1_Shnell", "FLUX.1",
@@ -73,4 +165,4 @@ public class MessageExt
     public string ComputedReasoning { get; set; } = string.Empty;
     public List<string> AttachedFiles { get; set; } = new();
     public List<(string Name, string Base64)> AttachedImages { get; set; } = new();
-}
+}
\ No newline at end of file
diff --git a/src/MaIN.InferPage/wwwroot/app.css b/src/MaIN.InferPage/wwwroot/app.css
index eb29837b..9db1b7a6 100644
--- a/src/MaIN.InferPage/wwwroot/app.css
+++ b/src/MaIN.InferPage/wwwroot/app.css
@@ -1,27 +1,40 @@
 @import url('https://fonts.googleapis.com/css2?family=Tiny5&display=swap'); /* Importing a coding font */
 
-/* Kolor akcentu ciemny motyw */
+/* Accent palette — dark theme.
+   FAST computes accent-fill-hover, accent-stroke-control-* and focus-stroke-outer
+   from accent-base-color, but its algorithm produces blue. Override explicitly. */
 body[data-theme="dark"],
 body[data-theme="system-dark"] {
     --accent-base-color: #00ffcc !important;
     --accent-fill-rest: #00ffcc !important;
+    --accent-fill-hover: #00e6b8 !important;
+    --accent-fill-active: #00cca3 !important;
+    --accent-stroke-control-rest: #00ffcc !important;
+    --accent-stroke-control-hover: #00e6b8 !important;
+    --focus-stroke-outer: #00ffcc !important;
 }
 
-/* Lekko szare tło + kolor akcentu jasny motyw */
+/* Accent palette + neutral layers — light theme.
+   Input fields use white (#fff) so they stand out from the panel background (#f0f0f0). */
 body[data-theme="light"],
 body[data-theme="system-light"],
 body:not([data-theme="dark"]):not([data-theme="system-dark"]) {
     --accent-base-color: #00cca3 !important;
     --accent-fill-rest: #00cca3 !important;
+    --accent-fill-hover: #00b892 !important;
+    --accent-fill-active: #00a583 !important;
+    --accent-stroke-control-rest: #00cca3 !important;
+    --accent-stroke-control-hover: #00b892 !important;
+    --focus-stroke-outer: #00cca3 !important;
     --light-bg: #f0f0f0;
     --neutral-layer-1: var(--light-bg) !important;
     --neutral-fill-layer-rest: var(--light-bg) !important;
-    --neutral-fill-input-rest: var(--light-bg) !important;
+    --neutral-fill-input-rest: #ffffff !important;
+    --neutral-fill-input-hover: #f5f5f5 !important;
+    --neutral-fill-input-active: #efefef !important;
     --neutral-layer-2: #e8e8e8 !important;
     --neutral-layer-3: #e0e0e0 !important;
     --neutral-layer-4: #d8d8d8 !important;
-    --neutral-fill-input-hover: #ebebeb !important;
-    --neutral-fill-input-active: #e8e8e8 !important;
 }
 
 body {
diff --git a/src/MaIN.InferPage/wwwroot/settings.css b/src/MaIN.InferPage/wwwroot/settings.css
new file mode 100644
index 00000000..c0807cda
--- /dev/null
+++ b/src/MaIN.InferPage/wwwroot/settings.css
@@ -0,0 +1,116 @@
+.settings-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 5000;
+    backdrop-filter: blur(3px);
+}
+
+.settings-panel {
+    background: var(--neutral-layer-1);
+    border-radius: 12px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+    width: 480px;
+    max-width: 90vw;
+    max-height: 85vh;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+}
+
+.settings-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 20px 24px 12px;
+    border-bottom: 1px solid var(--neutral-stroke-rest);
+}
+
+.settings-header h2 {
+    margin: 0;
+    color: var(--accent-base-color);
+    font-size: 1.25rem;
+}
+
+.settings-body {
+    padding: 20px 24px;
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+.settings-field {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+
+.settings-label {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--neutral-foreground-rest);
+}
+
+.settings-footer {
+    padding: 12px 24px 20px;
+    display: flex;
+    justify-content: flex-end;
+    border-top: 1px solid var(--neutral-stroke-rest);
+}
+
+.api-key-row {
+    display: flex;
+    align-items: flex-end;
+    gap: 4px;
+}
+
+.api-key-hint {
+    font-size: 12px;
+    color: var(--neutral-foreground-hint);
+    font-family: monospace;
+}
+
+.capabilities-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    align-items: center;
+}
+
+.capabilities-hint {
+    font-size: 12px;
+    color: var(--neutral-foreground-hint);
+}
+
+.capabilities-checkboxes {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.no-capabilities {
+    font-size: 13px;
+    color: var(--neutral-foreground-hint);
+    font-style: italic;
+}
+
+@media (max-width: 600px) {
+    .settings-panel {
+        width: 95vw;
+        max-height: 90vh;
+        border-radius: 8px;
+    }
+
+    .settings-header,
+    .settings-body,
+    .settings-footer {
+        padding-left: 16px;
+        padding-right: 16px;
+    }
+}
\ No newline at end of file
diff --git a/src/MaIN.InferPage/wwwroot/settings.js b/src/MaIN.InferPage/wwwroot/settings.js
new file mode 100644
index 00000000..e26c8010
--- /dev/null
+++ b/src/MaIN.InferPage/wwwroot/settings.js
@@ -0,0 +1,20 @@
+window.settingsManager = {
+    save: function (key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+    },
+    load: function (key) {
+        try {
+            var raw = localStorage.getItem(key);
+            if (!raw) return null;
+            return JSON.parse(raw);
+        } catch (e) {
+            return null;
+        }
+    },
+    remove: function (key) {
+        localStorage.removeItem(key);
+    },
+    exists: function (key) {
+        return localStorage.getItem(key) !== null;
+    }
+};
\ No newline at end of file
diff --git a/src/MaIN.Services/Services/LLMService/LLMService.cs b/src/MaIN.Services/Services/LLMService/LLMService.cs
index 2591e8a3..165e5fbe 100644
--- a/src/MaIN.Services/Services/LLMService/LLMService.cs
+++ b/src/MaIN.Services/Services/LLMService/LLMService.cs
@@ -73,7 +73,7 @@ public LLMService(
             return await ProcessWithToolsAsync(chat, requestOptions, cancellationToken);
         }
 
-        var model = GetLocalModel(chat.ModelId);
+        var model = GetLocalModel(chat);
         var tokens = await ProcessChatRequest(chat, model, lastMsg, requestOptions, cancellationToken);
         lastMsg.MarkProcessed();
         return await CreateChatResult(chat, tokens, requestOptions);
@@ -108,8 +108,8 @@ public Task CleanSessionCache(string? id)
         ChatRequestOptions requestOptions,
         CancellationToken cancellationToken = default)
     {
-        var model = GetLocalModel(chat.ModelId);
-        var parameters = new ModelParams(Path.Combine(modelsPath, model.FileName))
+        var model = GetLocalModel(chat);
+        var parameters = new ModelParams(ResolvePath(null, model.FileName))
         {
             GpuLayerCount = chat.MemoryParams.GpuLayerCount,
             ContextSize = (uint)chat.MemoryParams.ContextSize,
@@ -236,7 +236,7 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
 
         var visionModel = model as IVisionModel;
         var llavaWeights = visionModel?.MMProjectName is not null
-            ? await LLavaWeights.LoadFromFileAsync(Path.Combine(modelsPath, visionModel.MMProjectName), cancellationToken)
+            ? await LLavaWeights.LoadFromFileAsync(ResolvePath(null, visionModel.MMProjectName), cancellationToken)
             : null;
         
         using var executor = new BatchedExecutor(llmModel, parameters);
@@ -272,7 +272,7 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
 
     private ModelParams CreateModelParameters(Chat chat, string modelKey, string? customPath)
     {
-        return new ModelParams(Path.Combine(customPath ?? modelsPath, modelKey))
+        return new ModelParams(ResolvePath(customPath, modelKey))
         {
             ContextSize = (uint?)chat.InterferenceParams.ContextSize,
             GpuLayerCount = chat.InterferenceParams.GpuLayerCount,
@@ -500,25 +500,57 @@ private static BaseSamplingPipeline CreateSampler(InferenceParams interferencePa
         };
     }
 
-    private static LocalModel GetLocalModel(string modelId)
+    private static LocalModel GetLocalModel(Chat chat)
     {
-        var model = ModelRegistry.GetById(modelId);
-        if (model is not LocalModel localModel)
+        // 1. Use stored model instance if available
+        if (chat.ModelInstance is LocalModel storedLocal)
+            return storedLocal;
+
+        // 2. Try registry lookup (TryGetById to avoid throwing for unregistered models)
+        if (ModelRegistry.TryGetById(chat.ModelId, out var model) && model is LocalModel localModel)
+            return localModel;
+
+        // 3. Fallback: create generic local model for unregistered models
+        var modelId = chat.ModelId;
+        string fileName;
+        if (Path.IsPathFullyQualified(modelId))
         {
-            throw new InvalidModelTypeException(nameof(LocalModel));
+            // Fully-qualified path passed as ModelId — keep as-is.
+            // Applying Replace(':','-') would corrupt the drive letter: "C:\" → "C-\"
+            fileName = modelId.EndsWith(".gguf", StringComparison.OrdinalIgnoreCase)
+                ? modelId
+                : modelId + ".gguf";
         }
-        
-        return localModel;
+        else
+        {
+            // Model name only — replace ':' with '-' (colon is illegal in Windows file names)
+            fileName = modelId.Replace(':', '-');
+            if (!fileName.EndsWith(".gguf", StringComparison.OrdinalIgnoreCase))
+                fileName += ".gguf";
+        }
+        return new GenericLocalModel(FileName: fileName);
     }
 
     private string GetModelsPath()
     {
         var path = options.ModelsPath ?? Environment.GetEnvironmentVariable(DEFAULT_MODEL_ENV_PATH);
-        return string.IsNullOrEmpty(path) 
-            ? throw new ModelsPathNotFoundException() 
+        return string.IsNullOrEmpty(path)
+            ? throw new ModelsPathNotFoundException()
             : path;
     }
 
+    /// <summary>
+    /// Resolves the full path to a model file.
+    /// If <paramref name="fileName"/> is already fully qualified (absolute), it is used as-is.
+    /// Otherwise it is combined with <paramref name="customPath"/> (or <see cref="modelsPath"/>).
+    /// </summary>
+    private string ResolvePath(string? customPath, string fileName)
+    {
+        if (Path.IsPathFullyQualified(fileName))
+            return fileName;
+        return Path.Combine(customPath ?? modelsPath, fileName);
+    }
+
     private async Task<ChatResult> CreateChatResult(Chat chat, List<LLMTokenValue> tokens,
         ChatRequestOptions requestOptions)
     {

From da63125c397d09484c708df162bdd4e8f7ee09de Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Thu, 5 Mar 2026 23:20:44 +0100
Subject: [PATCH 2/9] Refactor settings, utils and startup logic

Several refactors and behavior fixes across the app:

- NavBar: call SettingsState.RequestSettings directly from the settings button, simplify theme toggle and reload helpers, remove unused flag/methods.
- Home: prevent adding image inputs when the selected model doesn't support vision and display an error.
- Settings page: build backend options with Prepend for simpler ordering.
- Program.cs: validate Self backend model at startup and exit if unsupported; adjust AddMaIN registration flow based on NeedsConfiguration and BackendType.
- SettingsService: convert to constructor-injected style, consolidate load/save into generic dict helpers, and add typed methods for saving/getting API keys and model history.
- SettingsStateService: shorten comment describing the event bus.
- Utils: unify capability checks with a generic GetCapability<T>, make Reason mutually exclusive with ImageGen, and streamline environment variable handling when setting backend API keys.

These changes simplify codepaths, centralize settings persistence logic, and enforce model capability checks earlier and at the UI level.
---
 .../Components/Layout/NavBar.razor            | 21 +---
 .../Components/Pages/Home.razor               | 10 ++
 .../Components/Pages/Settings.razor           | 12 +--
 src/MaIN.InferPage/Program.cs                 | 27 ++----
 .../Services/SettingsService.cs               | 64 ++++---------
 .../Services/SettingsStateService.cs          |  5 +-
 src/MaIN.InferPage/Utils.cs                   | 95 +++++--------------
 7 files changed, 69 insertions(+), 165 deletions(-)

diff --git a/src/MaIN.InferPage/Components/Layout/NavBar.razor b/src/MaIN.InferPage/Components/Layout/NavBar.razor
index 46ff6e78..63c6e373 100644
--- a/src/MaIN.InferPage/Components/Layout/NavBar.razor
+++ b/src/MaIN.InferPage/Components/Layout/NavBar.razor
@@ -54,7 +54,7 @@
         <FluentButton Style="background-color: transparent;"
                       BackgroundColor="rgba(0, 0, 0, 0)"
                       Appearance="Appearance.Lightweight"
-                      OnClick="@OpenSettings" IconStart="@(new Icons.Regular.Size24.Settings().WithColor(AccentColor))">
+                      OnClick="@(() => SettingsState.RequestSettings())" IconStart="@(new Icons.Regular.Size24.Settings().WithColor(AccentColor))">
         </FluentButton>
         <FluentButton Style="padding: 10px; background-color: transparent;"
                       BackgroundColor="rgba(0, 0, 0, 0)"
@@ -72,7 +72,6 @@
 @code {
     private DesignThemeModes Mode { get; set; }
     private string AccentColor => Mode == DesignThemeModes.Dark ? "#00ffcc" : "#00cca3";
-    private bool _isChangingTheme = false;
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
@@ -91,22 +90,10 @@
     }
 
     private void SetTheme()
-    {
-        if (_isChangingTheme) return;
-        _isChangingTheme = true;
-        Mode = Mode == DesignThemeModes.Dark ? DesignThemeModes.Light : DesignThemeModes.Dark;
-        _isChangingTheme = false;
-    }
+        => Mode = Mode == DesignThemeModes.Dark ? DesignThemeModes.Light : DesignThemeModes.Dark;
 
-    private void Reload(MouseEventArgs obj)
-    {
-        _navigationManager.Refresh(true);
-    }
-
-    private void OpenSettings()
-    {
-        SettingsState.RequestSettings();
-    }
+    private void Reload()
+        => _navigationManager.Refresh(true);
 
     private string GetBackendColor()
     {
diff --git a/src/MaIN.InferPage/Components/Pages/Home.razor b/src/MaIN.InferPage/Components/Pages/Home.razor
index e11860ea..0ca5898b 100644
--- a/src/MaIN.InferPage/Components/Pages/Home.razor
+++ b/src/MaIN.InferPage/Components/Pages/Home.razor
@@ -460,6 +460,11 @@
 
                 if (ImageExtensions.Contains(extension))
                 {
+                    if (!Utils.Vision)
+                    {
+                        _errorMessage = "This model doesn't support image input.";
+                        continue;
+                    }
                     var base64 = Convert.ToBase64String(ms.ToArray());
                     ms.Position = 0;
                     _selectedImages.Add((fileInfo, base64));
@@ -506,6 +511,11 @@
 
             if (ImageExtensions.Contains(extension.ToLowerInvariant()))
             {
+                if (!Utils.Vision)
+                {
+                    _errorMessage = "This model doesn't support image input.";
+                    return;
+                }
                 _selectedImages.Add((fileInfo, base64Data));
             }
             else
diff --git a/src/MaIN.InferPage/Components/Pages/Settings.razor b/src/MaIN.InferPage/Components/Pages/Settings.razor
index f3f22942..541752d5 100644
--- a/src/MaIN.InferPage/Components/Pages/Settings.razor
+++ b/src/MaIN.InferPage/Components/Pages/Settings.razor
@@ -202,9 +202,7 @@
 
     protected override async Task OnInitializedAsync()
     {
-        var localOption = new BackendOption(0, "Local", BackendType.Self, false);
-
-        var backendOptions = new List<BackendOption>
+        _backendOptions = new List<BackendOption>
         {
             new(1, "OpenAI", BackendType.OpenAi, true),
             new(2, "Gemini", BackendType.Gemini, true),
@@ -214,11 +212,9 @@
             new(6, "xAI", BackendType.Xai, true),
             new(7, "Ollama (Local)", BackendType.Ollama, false),
             new(8, "Ollama (Cloud)", BackendType.Ollama, true)
-
-        }.OrderBy(x => x.DisplayName).ToList();
-
-        backendOptions.Insert(0, localOption);
-        _backendOptions = backendOptions;
+        }.OrderBy(x => x.DisplayName)
+         .Prepend(new BackendOption(0, "Local", BackendType.Self, false))
+         .ToList();
 
         await base.OnInitializedAsync();
     }
diff --git a/src/MaIN.InferPage/Program.cs b/src/MaIN.InferPage/Program.cs
index 6303b27e..86728b75 100644
--- a/src/MaIN.InferPage/Program.cs
+++ b/src/MaIN.InferPage/Program.cs
@@ -100,28 +100,19 @@
     return;
 }
 
-if (Utils.NeedsConfiguration)
+// For Self backend CLI mode, validate model before registering
+if (!Utils.NeedsConfiguration && Utils.BackendType == BackendType.Self
+    && Utils.Path == null && !ModelRegistry.Exists(Utils.Model!))
 {
-    // Register with defaults — will be reconfigured at runtime via Settings UI
-    builder.Services.AddMaIN(builder.Configuration);
-}
-else if (Utils.BackendType != BackendType.Self)
-{
-    builder.Services.AddMaIN(builder.Configuration, settings =>
-    {
-        settings.BackendType = Utils.BackendType;
-    });
+    Console.WriteLine($"Model: {Utils.Model} is not supported");
+    Environment.Exit(0);
 }
-else
-{
-    if (Utils.Path == null && !ModelRegistry.Exists(Utils.Model!))
-    {
-        Console.WriteLine($"Model: {Utils.Model} is not supported");
-        Environment.Exit(0);
-    }
 
+if (!Utils.NeedsConfiguration && Utils.BackendType != BackendType.Self)
+    builder.Services.AddMaIN(builder.Configuration, s => s.BackendType = Utils.BackendType);
+else
+    // NeedsConfiguration or Self backend: register with defaults
     builder.Services.AddMaIN(builder.Configuration);
-}
 
 var app = builder.Build();
 
diff --git a/src/MaIN.InferPage/Services/SettingsService.cs b/src/MaIN.InferPage/Services/SettingsService.cs
index 07144e54..fb7fc66d 100644
--- a/src/MaIN.InferPage/Services/SettingsService.cs
+++ b/src/MaIN.InferPage/Services/SettingsService.cs
@@ -2,67 +2,37 @@
 
 namespace MaIN.InferPage.Services;
 
-public class SettingsService
+public class SettingsService(IJSRuntime js)
 {
     private const string SettingsKey = "inferpage-settings";
     private const string ApiKeysKey = "inferpage-apikeys";
     private const string ModelHistoryKey = "inferpage-model-history";
 
-    private readonly IJSRuntime _js;
-
-    public SettingsService(IJSRuntime js)
-    {
-        _js = js;
-    }
-
     public async Task<InferPageSettings?> LoadSettingsAsync()
-    {
-        return await _js.InvokeAsync<InferPageSettings?>("settingsManager.load", SettingsKey);
-    }
+        => await js.InvokeAsync<InferPageSettings?>("settingsManager.load", SettingsKey);
 
     public async Task SaveSettingsAsync(InferPageSettings settings)
-    {
-        await _js.InvokeVoidAsync("settingsManager.save", SettingsKey, settings);
-    }
+        => await js.InvokeVoidAsync("settingsManager.save", SettingsKey, settings);
 
     public async Task<bool> HasSettingsAsync()
-    {
-        return await _js.InvokeAsync<bool>("settingsManager.exists", SettingsKey);
-    }
+        => await js.InvokeAsync<bool>("settingsManager.exists", SettingsKey);
 
-    public async Task<Dictionary<string, string>?> LoadApiKeysAsync()
-    {
-        return await _js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", ApiKeysKey);
-    }
+    public Task SaveApiKeyAsync(string backend, string key) => SetInDictAsync(ApiKeysKey, backend, key);
+    public Task<string?> GetApiKeyForBackendAsync(string backend) => GetFromDictAsync(ApiKeysKey, backend);
 
-    public async Task SaveApiKeyAsync(string backendName, string key)
-    {
-        var keys = await LoadApiKeysAsync() ?? new Dictionary<string, string>();
-        keys[backendName] = key;
-        await _js.InvokeVoidAsync("settingsManager.save", ApiKeysKey, keys);
-    }
-
-    public async Task<string?> GetApiKeyForBackendAsync(string backendName)
-    {
-        var keys = await LoadApiKeysAsync();
-        return keys?.GetValueOrDefault(backendName);
-    }
+    public Task SaveModelForBackendAsync(string backend, string model) => SetInDictAsync(ModelHistoryKey, backend, model);
+    public Task<string?> GetLastModelForBackendAsync(string backend) => GetFromDictAsync(ModelHistoryKey, backend);
 
-    public async Task<Dictionary<string, string>?> LoadModelHistoryAsync()
+    private async Task SetInDictAsync(string storageKey, string key, string value)
     {
-        return await _js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", ModelHistoryKey);
+        var dict = await LoadDictAsync(storageKey);
+        dict[key] = value;
+        await js.InvokeVoidAsync("settingsManager.save", storageKey, dict);
     }
 
-    public async Task SaveModelForBackendAsync(string backendName, string model)
-    {
-        var history = await LoadModelHistoryAsync() ?? new Dictionary<string, string>();
-        history[backendName] = model;
-        await _js.InvokeVoidAsync("settingsManager.save", ModelHistoryKey, history);
-    }
+    private async Task<string?> GetFromDictAsync(string storageKey, string key)
+        => (await LoadDictAsync(storageKey)).GetValueOrDefault(key);
 
-    public async Task<string?> GetLastModelForBackendAsync(string backendName)
-    {
-        var history = await LoadModelHistoryAsync();
-        return history?.GetValueOrDefault(backendName);
-    }
-}
\ No newline at end of file
+    private async Task<Dictionary<string, string>> LoadDictAsync(string storageKey)
+        => await js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", storageKey) ?? new();
+}
diff --git a/src/MaIN.InferPage/Services/SettingsStateService.cs b/src/MaIN.InferPage/Services/SettingsStateService.cs
index 1aef52b6..f6da3fb6 100644
--- a/src/MaIN.InferPage/Services/SettingsStateService.cs
+++ b/src/MaIN.InferPage/Services/SettingsStateService.cs
@@ -1,9 +1,6 @@
 namespace MaIN.InferPage.Services;
 
-/// <summary>
-/// Scoped service for cross-component settings event communication.
-/// NavBar (interactive) fires events, Home (interactive) subscribes.
-/// </summary>
+/// <summary>Event bus for NavBar ↔ Home sibling communication.</summary>
 public class SettingsStateService
 {
     public event Action? OnSettingsRequested;
diff --git a/src/MaIN.InferPage/Utils.cs b/src/MaIN.InferPage/Utils.cs
index 1a927625..a7a700a0 100644
--- a/src/MaIN.InferPage/Utils.cs
+++ b/src/MaIN.InferPage/Utils.cs
@@ -11,7 +11,8 @@ public static class Utils
     public static bool HasApiKey { get; set; }
     public static string? Path { get; set; }
     public static bool IsLocal => BackendType == BackendType.Self || (BackendType == BackendType.Ollama && !HasApiKey);
-    public static string? Model = "gemma3-4b";
+    public static string? Model;
+
     public static bool NeedsConfiguration { get; set; }
 
     // Manual capability overrides for unregistered models (set from Settings UI)
@@ -19,41 +20,17 @@ public static class Utils
     public static bool? ManualReasoning { get; set; }
     public static bool? ManualImageGen { get; set; }
 
-    public static bool Reason
-    {
-        get
-        {
-            if (string.IsNullOrEmpty(Model)) return false;
-            if (ModelRegistry.TryGetById(Model, out var m))
-                return m is IReasoningModel && !ImageGen; // reasoning and image gen are mutually exclusive
-            if (ManualReasoning.HasValue) return ManualReasoning.Value;
-            return false;
-        }
-    }
-
-    public static bool ImageGen
-    {
-        get
-        {
-            if (string.IsNullOrEmpty(Model)) return false;
-            if (ModelRegistry.TryGetById(Model, out var m))
-                return m is IImageGenerationModel;
-            if (ManualImageGen.HasValue) return ManualImageGen.Value;
-            return ImageGenerationModels.Contains(Model); // fallback for unregistered models (e.g. FLUX via separate server)
-        }
-    }
+    // registry → manual override → fallback set (null = no fallback)
+    private static bool GetCapability<T>(bool? manual, HashSet<string>? fallback = null)
+        where T : class =>
+        !string.IsNullOrEmpty(Model) && (
+            ModelRegistry.TryGetById(Model, out var m) ? m is T :
+            manual.HasValue ? manual.Value :
+            fallback?.Contains(Model) ?? false);
 
-    public static bool Vision
-    {
-        get
-        {
-            if (string.IsNullOrEmpty(Model)) return false;
-            if (ModelRegistry.TryGetById(Model, out var m))
-                return m is IVisionModel;
-            if (ManualVision.HasValue) return ManualVision.Value;
-            return VisionModels.Contains(Model); // fallback for unregistered models
-        }
-    }
+    public static bool ImageGen => GetCapability<IImageGenerationModel>(ManualImageGen, ImageGenerationModels);
+    public static bool Vision   => GetCapability<IVisionModel>(ManualVision, VisionModels);
+    public static bool Reason   => GetCapability<IReasoningModel>(ManualReasoning);
 
     public static bool IsKnownVisionModel(string model) => VisionModels.Contains(model);
     public static bool IsKnownImageGenModel(string model) => ImageGenerationModels.Contains(model);
@@ -95,44 +72,20 @@ public static void ApplySettings(
 
         mainSettings.BackendType = backendType;
 
-        if (!string.IsNullOrEmpty(apiKey))
-        {
-            var entry = LLMApiRegistry.GetEntry(backendType);
-            if (entry != null)
-            {
-                Environment.SetEnvironmentVariable(entry.ApiKeyEnvName, apiKey);
-            }
+        // null clears env var and key; handles both "set new key" and "clear stale key" cases
+        var entry = LLMApiRegistry.GetEntry(backendType);
+        if (entry != null)
+            Environment.SetEnvironmentVariable(entry.ApiKeyEnvName, apiKey);
 
-            switch (backendType)
-            {
-                case BackendType.OpenAi: mainSettings.OpenAiKey = apiKey; break;
-                case BackendType.Gemini: mainSettings.GeminiKey = apiKey; break;
-                case BackendType.DeepSeek: mainSettings.DeepSeekKey = apiKey; break;
-                case BackendType.Anthropic: mainSettings.AnthropicKey = apiKey; break;
-                case BackendType.GroqCloud: mainSettings.GroqCloudKey = apiKey; break;
-                case BackendType.Ollama: mainSettings.OllamaKey = apiKey; break;
-                case BackendType.Xai: mainSettings.XaiKey = apiKey; break;
-            }
-        }
-        else
+        switch (backendType)
         {
-            // Clear stale key for this backend (e.g. switching Ollama Cloud → Local)
-            var entry = LLMApiRegistry.GetEntry(backendType);
-            if (entry != null)
-            {
-                Environment.SetEnvironmentVariable(entry.ApiKeyEnvName, null);
-            }
-
-            switch (backendType)
-            {
-                case BackendType.OpenAi: mainSettings.OpenAiKey = null; break;
-                case BackendType.Gemini: mainSettings.GeminiKey = null; break;
-                case BackendType.DeepSeek: mainSettings.DeepSeekKey = null; break;
-                case BackendType.Anthropic: mainSettings.AnthropicKey = null; break;
-                case BackendType.GroqCloud: mainSettings.GroqCloudKey = null; break;
-                case BackendType.Ollama: mainSettings.OllamaKey = null; break;
-                case BackendType.Xai: mainSettings.XaiKey = null; break;
-            }
+            case BackendType.OpenAi: mainSettings.OpenAiKey = apiKey; break;
+            case BackendType.Gemini: mainSettings.GeminiKey = apiKey; break;
+            case BackendType.DeepSeek: mainSettings.DeepSeekKey = apiKey; break;
+            case BackendType.Anthropic: mainSettings.AnthropicKey = apiKey; break;
+            case BackendType.GroqCloud: mainSettings.GroqCloudKey = apiKey; break;
+            case BackendType.Ollama: mainSettings.OllamaKey = apiKey; break;
+            case BackendType.Xai: mainSettings.XaiKey = apiKey; break;
         }
     }
 

From 91894b2c397542c82e81662baec4255c5e1d7de5 Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Thu, 5 Mar 2026 23:46:27 +0100
Subject: [PATCH 3/9] Persist backend profiles with capabilities

Add per-backend profile storage (model + capability flags) and use it in settings UI. SettingsService: introduce BackendProfile record and SaveProfileForBackendAsync/GetProfileForBackendAsync using a new storage key. Settings.razor: load profile on backend select, restore manual vision/reasoning/imagegen flags only for unregistered models, fallback to legacy model-history when no profile exists, and save the full profile instead of just the model. This enables preserving capability information per backend while remaining compatible with older model-only entries.
---
 .../Components/Pages/Settings.razor           | 27 +++++++++++++++----
 .../Services/SettingsService.cs               | 20 ++++++++++++++
 .../Services/LLMService/DeepSeekService.cs    |  1 +
 .../Services/LLMService/OllamaService.cs      |  1 +
 4 files changed, 44 insertions(+), 5 deletions(-)

diff --git a/src/MaIN.InferPage/Components/Pages/Settings.razor b/src/MaIN.InferPage/Components/Pages/Settings.razor
index 541752d5..ce5fe1e1 100644
--- a/src/MaIN.InferPage/Components/Pages/Settings.razor
+++ b/src/MaIN.InferPage/Components/Pages/Settings.razor
@@ -278,11 +278,27 @@
         if (_selectedBackend == null) return;
 
         var backendKey = GetBackendStorageKey();
-        var lastModel = await SettingsStorage.GetLastModelForBackendAsync(backendKey);
-        if (!string.IsNullOrEmpty(lastModel))
+        var profile = await SettingsStorage.GetProfileForBackendAsync(backendKey);
+        if (profile != null)
         {
-            _modelName = lastModel;
-            OnModelNameChanged();
+            _modelName = profile.Model;
+            OnModelNameChanged();                    // sets _isRegisteredModel + auto-detects caps
+            if (!_isRegisteredModel)                // only restore manual caps for unregistered models
+            {
+                _manualVision    = profile.Vision;
+                _manualReasoning = profile.Reasoning;
+                _manualImageGen  = profile.ImageGen;
+            }
+        }
+        else
+        {
+            // Fallback: old model-history entry (no capability info)
+            var lastModel = await SettingsStorage.GetLastModelForBackendAsync(backendKey);
+            if (!string.IsNullOrEmpty(lastModel))
+            {
+                _modelName = lastModel;
+                OnModelNameChanged();
+            }
         }
 
         await LoadApiKeyPreview();
@@ -370,7 +386,8 @@
         };
         await SettingsStorage.SaveSettingsAsync(settings);
 
-        await SettingsStorage.SaveModelForBackendAsync(backendKey, _modelName);
+        await SettingsStorage.SaveProfileForBackendAsync(
+            backendKey, _modelName, hasVision, hasReasoning, hasImageGen);
 
         // Resolve API key: use new input, or fall back to saved key
         string? apiKey = null;
diff --git a/src/MaIN.InferPage/Services/SettingsService.cs b/src/MaIN.InferPage/Services/SettingsService.cs
index fb7fc66d..71e88d3a 100644
--- a/src/MaIN.InferPage/Services/SettingsService.cs
+++ b/src/MaIN.InferPage/Services/SettingsService.cs
@@ -23,6 +23,24 @@ public async Task<bool> HasSettingsAsync()
     public Task SaveModelForBackendAsync(string backend, string model) => SetInDictAsync(ModelHistoryKey, backend, model);
     public Task<string?> GetLastModelForBackendAsync(string backend) => GetFromDictAsync(ModelHistoryKey, backend);
 
+    private const string BackendProfilesKey = "inferpage-backend-profiles";
+
+    public async Task SaveProfileForBackendAsync(string backend, string model,
+        bool vision, bool reasoning, bool imageGen)
+    {
+        var profiles = await js.InvokeAsync<Dictionary<string, BackendProfile>?>(
+            "settingsManager.load", BackendProfilesKey) ?? new();
+        profiles[backend] = new BackendProfile(model, vision, reasoning, imageGen);
+        await js.InvokeVoidAsync("settingsManager.save", BackendProfilesKey, profiles);
+    }
+
+    public async Task<BackendProfile?> GetProfileForBackendAsync(string backend)
+    {
+        var profiles = await js.InvokeAsync<Dictionary<string, BackendProfile>?>(
+            "settingsManager.load", BackendProfilesKey);
+        return profiles?.GetValueOrDefault(backend);
+    }
+
     private async Task SetInDictAsync(string storageKey, string key, string value)
     {
         var dict = await LoadDictAsync(storageKey);
@@ -36,3 +54,5 @@ private async Task SetInDictAsync(string storageKey, string key, string value)
     private async Task<Dictionary<string, string>> LoadDictAsync(string storageKey)
         => await js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", storageKey) ?? new();
 }
+
+public record BackendProfile(string Model, bool Vision, bool Reasoning, bool ImageGen);
diff --git a/src/MaIN.Services/Services/LLMService/DeepSeekService.cs b/src/MaIN.Services/Services/LLMService/DeepSeekService.cs
index f64eb3df..245b66b9 100644
--- a/src/MaIN.Services/Services/LLMService/DeepSeekService.cs
+++ b/src/MaIN.Services/Services/LLMService/DeepSeekService.cs
@@ -67,6 +67,7 @@ protected override void ValidateApiKey()
 
         chat.Messages.Last().Content = message.Content;
         chat.Messages.Last().Files = [];
+        chat.Messages.Last().Images = null;
         var result = await Send(chat, requestOptions, cancellationToken);
         chat.Messages.Last().Content = lastMsg.Content;
         return result;
diff --git a/src/MaIN.Services/Services/LLMService/OllamaService.cs b/src/MaIN.Services/Services/LLMService/OllamaService.cs
index 74da470e..66075d93 100644
--- a/src/MaIN.Services/Services/LLMService/OllamaService.cs
+++ b/src/MaIN.Services/Services/LLMService/OllamaService.cs
@@ -58,6 +58,7 @@ protected override void ValidateApiKey()
 
         chat.Messages.Last().Content = message.Content;
         chat.Messages.Last().Files = [];
+        chat.Messages.Last().Images = null;
         var result = await Send(chat, requestOptions, cancellationToken);
         chat.Messages.Last().Content = lastMsg.Content;
         return result;

From 7e192e6fc8152d0866aca50d20140ff93f796713 Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Fri, 6 Mar 2026 10:38:38 +0100
Subject: [PATCH 4/9] Support MMProj files & extract image uploads

Add support for multimodal projector (.mmproj) names across the stack and ensure uploaded image files are treated as images. Implemented MMProjectName on several local vision models and added MmProjName property to InferPage settings, backend profiles, Utils, and ServiceConstants. Settings UI now exposes an MMProj File input for local unregistered vision models and saves/loads it per backend. LLMService now extracts image files from message.Files early (ChatHelper.ExtractImageFromFiles), resolves mmproj name from the model or chat properties to load LLava weights, and requires loaded weights before processing image messages. ChatHelper.ExtractImageFromFiles moves image files into message.Images and cleans up Files so they aren't misrouted to RAG/memory.
---
 .../Models/Concrete/LocalModels.cs            | 15 ++++--
 .../Components/Pages/Home.razor               |  8 ++++
 .../Components/Pages/Settings.razor           | 20 +++++++-
 .../Services/InferPageSettings.cs             |  1 +
 .../Services/SettingsService.cs               |  6 +--
 src/MaIN.InferPage/Utils.cs                   |  3 ++
 .../Constants/ServiceConstants.cs             |  1 +
 .../Services/LLMService/LLMService.cs         | 10 ++--
 .../Services/LLMService/Utils/ChatHelper.cs   | 47 +++++++++++++++++++
 9 files changed, 100 insertions(+), 11 deletions(-)

diff --git a/src/MaIN.Domain/Models/Concrete/LocalModels.cs b/src/MaIN.Domain/Models/Concrete/LocalModels.cs
index 7ac871e7..3cb5672f 100644
--- a/src/MaIN.Domain/Models/Concrete/LocalModels.cs
+++ b/src/MaIN.Domain/Models/Concrete/LocalModels.cs
@@ -18,7 +18,10 @@ public sealed record Gemma3_4b() : LocalModel(
     new Uri("https://huggingface.co/Inza124/Gemma3-4b/resolve/main/gemma3-4b.gguf?download=true"),
     "Gemma3 4B",
     8192,
-    "Balanced 4B model for writing, analysis, and mathematical reasoning");
+    "Balanced 4B model for writing, analysis, and mathematical reasoning"), IVisionModel
+{
+    public string MMProjectName => "mmproj-model-gemma3-4b.gguf";
+}
 
 public sealed record Gemma3_12b() : LocalModel(
     "gemma3-12b",
@@ -26,7 +29,10 @@ public sealed record Gemma3_12b() : LocalModel(
     new Uri("https://huggingface.co/Inza124/Gemma3-12b/resolve/main/gemma3-12b.gguf?download=true"),
     "Gemma3 12B",
     8192,
-    "Large 12B model for complex analysis, research, and creative writing");
+    "Large 12B model for complex analysis, research, and creative writing"), IVisionModel
+{
+    public string MMProjectName => "mmproj-model-gemma3-12b.gguf";
+}
 
 public sealed record Gemma3n_e4b() : LocalModel(
     "gemma3n-e4b",
@@ -34,7 +40,10 @@ public sealed record Gemma3n_e4b() : LocalModel(
     new Uri("https://huggingface.co/Inza124/Gemma-3n-e4b/resolve/main/gemma-3n-e4b.gguf?download=true"),
     "Gemma3n E4B",
     8192,
-    "Compact 4B model optimized for efficient reasoning and general-purpose tasks");
+    "Compact 4B model optimized for efficient reasoning and general-purpose tasks"), IVisionModel
+{
+    public string MMProjectName => "mmproj-model-gemma3n-e4b.gguf";
+}
 
 // ===== Llama Family =====
 
diff --git a/src/MaIN.InferPage/Components/Pages/Home.razor b/src/MaIN.InferPage/Components/Pages/Home.razor
index 0ca5898b..bd8d73d3 100644
--- a/src/MaIN.InferPage/Components/Pages/Home.razor
+++ b/src/MaIN.InferPage/Components/Pages/Home.razor
@@ -12,6 +12,8 @@
 @using MaIN.Domain.Exceptions
 @using MaIN.Domain.Models
 @using MaIN.Domain.Models.Abstract
+@using MaIN.Services
+@using MaIN.Services.Constants
 @using Markdig
 @using Message = MaIN.Domain.Entities.Message
 @using MessageType = MaIN.Domain.Entities.MessageType
@@ -396,6 +398,7 @@
             settings.HasVision,
             settings.HasReasoning,
             settings.HasImageGen,
+            settings.MmProjName,
             MaINSettings,
             apiKey);
     }
@@ -592,6 +595,11 @@
             Chat.ModelId = Utils.Model!;
             Chat.ImageGen = Utils.ImageGen;
 
+            // Sync mmproj setting for local unregistered vision models
+            Chat.Properties.Remove(ServiceConstants.Properties.MmProjNameProperty);
+            if (Utils.BackendType == BackendType.Self && !string.IsNullOrEmpty(Utils.MmProjName))
+                Chat.Properties.AddProperty(ServiceConstants.Properties.MmProjNameProperty, Utils.MmProjName);
+
             bool wasAtBottom = await JS.InvokeAsync<bool>("scrollManager.isAtBottom", "messages-container");
 
             StateHasChanged();
diff --git a/src/MaIN.InferPage/Components/Pages/Settings.razor b/src/MaIN.InferPage/Components/Pages/Settings.razor
index ce5fe1e1..3a60a2b4 100644
--- a/src/MaIN.InferPage/Components/Pages/Settings.razor
+++ b/src/MaIN.InferPage/Components/Pages/Settings.razor
@@ -115,6 +115,17 @@
                     }
                 </div>
             }
+
+            @if (_selectedBackend?.BackendType == BackendType.Self && !_isRegisteredModel && _manualVision)
+            {
+                <div class="settings-field">
+                    <label class="settings-label">MMProj File</label>
+                    <FluentTextField @bind-Value="_mmProjName"
+                                     Placeholder="e.g., mmproj-model-f16.gguf"
+                                     Style="width: 100%;" />
+                    <span class="api-key-hint">Multimodal projector file (must be in the models folder)</span>
+                </div>
+            }
         </div>
 
         <div class="settings-footer">
@@ -194,6 +205,7 @@
     private bool _manualVision;
     private bool _manualReasoning;
     private bool _manualImageGen;
+    private string? _mmProjName;
 
     private bool RequiresApiKey => _selectedBackend?.RequiresApiKey == true;
     private bool CanSave => !string.IsNullOrWhiteSpace(_modelName)
@@ -251,6 +263,7 @@
             _manualVision = settings.HasVision;
             _manualReasoning = settings.HasReasoning;
             _manualImageGen = settings.HasImageGen;
+            _mmProjName = settings.MmProjName;
 
             OnModelNameChanged();
         }
@@ -288,6 +301,7 @@
                 _manualVision    = profile.Vision;
                 _manualReasoning = profile.Reasoning;
                 _manualImageGen  = profile.ImageGen;
+                _mmProjName      = profile.MmProjName;
             }
         }
         else
@@ -382,12 +396,13 @@
             HasVision = hasVision,
             HasReasoning = hasReasoning,
             HasImageGen = hasImageGen,
-            ModelPath = _modelPath
+            ModelPath = _modelPath,
+            MmProjName = _mmProjName
         };
         await SettingsStorage.SaveSettingsAsync(settings);
 
         await SettingsStorage.SaveProfileForBackendAsync(
-            backendKey, _modelName, hasVision, hasReasoning, hasImageGen);
+            backendKey, _modelName, hasVision, hasReasoning, hasImageGen, _mmProjName);
 
         // Resolve API key: use new input, or fall back to saved key
         string? apiKey = null;
@@ -411,6 +426,7 @@
             hasVision,
             hasReasoning,
             hasImageGen,
+            _mmProjName,
             MaINSettings,
             apiKey);
 
diff --git a/src/MaIN.InferPage/Services/InferPageSettings.cs b/src/MaIN.InferPage/Services/InferPageSettings.cs
index ec66cbc2..48bddd4c 100644
--- a/src/MaIN.InferPage/Services/InferPageSettings.cs
+++ b/src/MaIN.InferPage/Services/InferPageSettings.cs
@@ -9,4 +9,5 @@ public class InferPageSettings
     public bool HasReasoning { get; set; }
     public bool HasImageGen { get; set; }
     public string? ModelPath { get; set; }
+    public string? MmProjName { get; set; }
 }
\ No newline at end of file
diff --git a/src/MaIN.InferPage/Services/SettingsService.cs b/src/MaIN.InferPage/Services/SettingsService.cs
index 71e88d3a..db52934c 100644
--- a/src/MaIN.InferPage/Services/SettingsService.cs
+++ b/src/MaIN.InferPage/Services/SettingsService.cs
@@ -26,11 +26,11 @@ public async Task<bool> HasSettingsAsync()
     private const string BackendProfilesKey = "inferpage-backend-profiles";
 
     public async Task SaveProfileForBackendAsync(string backend, string model,
-        bool vision, bool reasoning, bool imageGen)
+        bool vision, bool reasoning, bool imageGen, string? mmProjName = null)
     {
         var profiles = await js.InvokeAsync<Dictionary<string, BackendProfile>?>(
             "settingsManager.load", BackendProfilesKey) ?? new();
-        profiles[backend] = new BackendProfile(model, vision, reasoning, imageGen);
+        profiles[backend] = new BackendProfile(model, vision, reasoning, imageGen, mmProjName);
         await js.InvokeVoidAsync("settingsManager.save", BackendProfilesKey, profiles);
     }
 
@@ -55,4 +55,4 @@ private async Task<Dictionary<string, string>> LoadDictAsync(string storageKey)
         => await js.InvokeAsync<Dictionary<string, string>?>("settingsManager.load", storageKey) ?? new();
 }
 
-public record BackendProfile(string Model, bool Vision, bool Reasoning, bool ImageGen);
+public record BackendProfile(string Model, bool Vision, bool Reasoning, bool ImageGen, string? MmProjName = null);
diff --git a/src/MaIN.InferPage/Utils.cs b/src/MaIN.InferPage/Utils.cs
index a7a700a0..49c297b5 100644
--- a/src/MaIN.InferPage/Utils.cs
+++ b/src/MaIN.InferPage/Utils.cs
@@ -19,6 +19,7 @@ public static class Utils
     public static bool? ManualVision { get; set; }
     public static bool? ManualReasoning { get; set; }
     public static bool? ManualImageGen { get; set; }
+    public static string? MmProjName { get; set; }
 
     // registry → manual override → fallback set (null = no fallback)
     private static bool GetCapability<T>(bool? manual, HashSet<string>? fallback = null)
@@ -42,6 +43,7 @@ public static void ApplySettings(
         bool hasVision,
         bool hasReasoning,
         bool hasImageGen,
+        string? mmProjName,
         MaINSettings mainSettings,
         string? apiKey)
     {
@@ -69,6 +71,7 @@ public static void ApplySettings(
         ManualVision = hasVision;
         ManualReasoning = hasReasoning;
         ManualImageGen = hasImageGen;
+        MmProjName = string.IsNullOrWhiteSpace(mmProjName) ? null : mmProjName.Trim();
 
         mainSettings.BackendType = backendType;
 
diff --git a/src/MaIN.Services/Constants/ServiceConstants.cs b/src/MaIN.Services/Constants/ServiceConstants.cs
index 853f5659..a38ee412 100644
--- a/src/MaIN.Services/Constants/ServiceConstants.cs
+++ b/src/MaIN.Services/Constants/ServiceConstants.cs
@@ -62,6 +62,7 @@ public static class Properties
         public const string PreProcessProperty = "Pre_Process";
         public const string DisableCacheProperty = "DisableCache";
         public const string AgentIdProperty = "AgentId";
+        public const string MmProjNameProperty = "MmProjName";
     }
 
     public static class Defaults
diff --git a/src/MaIN.Services/Services/LLMService/LLMService.cs b/src/MaIN.Services/Services/LLMService/LLMService.cs
index 165e5fbe..b57fcb8b 100644
--- a/src/MaIN.Services/Services/LLMService/LLMService.cs
+++ b/src/MaIN.Services/Services/LLMService/LLMService.cs
@@ -62,6 +62,8 @@ public LLMService(
 
         var lastMsg = chat.Messages.Last();
 
+        await ChatHelper.ExtractImageFromFiles(lastMsg);
+
         if (ChatHelper.HasFiles(lastMsg))
         {
             var memoryOptions = ChatHelper.ExtractMemoryOptions(lastMsg);
@@ -235,8 +237,10 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
             : await ModelLoader.GetOrLoadModelAsync(modelsPath, modelKey);
 
         var visionModel = model as IVisionModel;
-        var llavaWeights = visionModel?.MMProjectName is not null
-            ? await LLavaWeights.LoadFromFileAsync(ResolvePath(null, visionModel.MMProjectName), cancellationToken)
+        var mmProjName = visionModel?.MMProjectName
+            ?? (chat.Properties.TryGetValue(ServiceConstants.Properties.MmProjNameProperty, out var p) ? p : null);
+        var llavaWeights = mmProjName is not null
+            ? await LLavaWeights.LoadFromFileAsync(ResolvePath(null, mmProjName), cancellationToken)
             : null;
         
         using var executor = new BatchedExecutor(llmModel, parameters);
@@ -299,7 +303,7 @@ private ModelParams CreateModelParameters(Chat chat, string modelKey, string? cu
             ? executor.Create()
             : executor.Load(chat.ConversationState!);
 
-        if (lastMsg.Image != null)
+        if (lastMsg.Image != null && llavaWeights != null)
         {
             await ProcessImageMessage(conversation, lastMsg, llmModel, llavaWeights, executor, cancellationToken);
         }
diff --git a/src/MaIN.Services/Services/LLMService/Utils/ChatHelper.cs b/src/MaIN.Services/Services/LLMService/Utils/ChatHelper.cs
index f0f7a9a4..5b3119e9 100644
--- a/src/MaIN.Services/Services/LLMService/Utils/ChatHelper.cs
+++ b/src/MaIN.Services/Services/LLMService/Utils/ChatHelper.cs
@@ -13,6 +13,53 @@ namespace MaIN.Services.Services.LLMService.Utils;
 /// </summary>
 public static class ChatHelper
 {
+    private static readonly HashSet<string> ImageExtensions =
+    [
+        ".jpg", ".jpeg", ".png", ".gif", ".webp",
+        ".bmp", ".tiff", ".tif", ".heic", ".heif", ".avif"
+    ];
+
+    /// <summary>
+    /// Extracts image files from message.Files into message.Images and removes them from Files.
+    /// This must be called before HasFiles() so images are not mistakenly routed to the RAG/memory path.
+    /// </summary>
+    public static async Task ExtractImageFromFiles(Message message)
+    {
+        if (message.Files == null || message.Files.Count == 0)
+            return;
+
+        var imageFiles = message.Files
+            .Where(f => ImageExtensions.Contains(f.Extension.ToLowerInvariant()))
+            .ToList();
+
+        if (imageFiles.Count == 0)
+            return;
+
+        var imageBytesList = new List<byte[]>();
+        foreach (var imageFile in imageFiles)
+        {
+            if (imageFile.StreamContent != null)
+            {
+                using var ms = new MemoryStream();
+                imageFile.StreamContent.Position = 0;
+                await imageFile.StreamContent.CopyToAsync(ms);
+                imageBytesList.Add(ms.ToArray());
+            }
+            else if (imageFile.Path != null)
+            {
+                imageBytesList.Add(await File.ReadAllBytesAsync(imageFile.Path));
+            }
+
+            message.Files.Remove(imageFile);
+        }
+
+        message.Images = imageBytesList;
+
+        if (message.Files.Count == 0)
+            message.Files = null;
+    }
+
+
     /// <summary>
     /// Generates final prompt including additional prompt if needed
     /// </summary>

From 1041cc5df6307b7d2ea188b3528fa8d954a0661d Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Fri, 6 Mar 2026 10:40:27 +0100
Subject: [PATCH 5/9] Fix vision for local models

---
 src/MaIN.Core/MaIN.Core.csproj                |  2 +-
 src/MaIN.Domain/MaIN.Domain.csproj            |  2 +-
 src/MaIN.Services/MaIN.Services.csproj        |  6 +--
 .../Services/LLMService/LLMService.cs         | 39 +++++++++++--------
 4 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/src/MaIN.Core/MaIN.Core.csproj b/src/MaIN.Core/MaIN.Core.csproj
index f6f1f348..667eedf9 100644
--- a/src/MaIN.Core/MaIN.Core.csproj
+++ b/src/MaIN.Core/MaIN.Core.csproj
@@ -8,7 +8,7 @@
 
     <ItemGroup>
         <PackageReference Include="AsyncKeyedLock" Version="8.0.2" />
-        <PackageReference Include="LLamaSharp.Backend.Cuda12" Version="0.25.0" />
+        <PackageReference Include="LLamaSharp.Backend.Cuda12" Version="0.26.0" />
         <PackageReference Include="Tesseract.Data.English" Version="4.0.0" />
     </ItemGroup>
 
diff --git a/src/MaIN.Domain/MaIN.Domain.csproj b/src/MaIN.Domain/MaIN.Domain.csproj
index f6f64701..612f95d4 100644
--- a/src/MaIN.Domain/MaIN.Domain.csproj
+++ b/src/MaIN.Domain/MaIN.Domain.csproj
@@ -8,7 +8,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="LLamaSharp" Version="0.25.0" />
+      <PackageReference Include="LLamaSharp" Version="0.26.0" />
     </ItemGroup>
 
 </Project>
diff --git a/src/MaIN.Services/MaIN.Services.csproj b/src/MaIN.Services/MaIN.Services.csproj
index 9e0ad478..308b0449 100644
--- a/src/MaIN.Services/MaIN.Services.csproj
+++ b/src/MaIN.Services/MaIN.Services.csproj
@@ -15,9 +15,9 @@
     <ItemGroup>
       <PackageReference Include="GTranslate" Version="2.3.1" />
       <PackageReference Include="HtmlAgilityPack" Version="1.12.4" />
-      <PackageReference Include="llamasharp.backend.cpu" Version="0.25.0" />
-      <PackageReference Include="LLamaSharp.Backend.Cuda12" Version="0.25.0" />
-      <PackageReference Include="LLamaSharp.kernel-memory" Version="0.25.0" />
+      <PackageReference Include="llamasharp.backend.cpu" Version="0.26.0" />
+      <PackageReference Include="LLamaSharp.Backend.Cuda12" Version="0.26.0" />
+      <PackageReference Include="LLamaSharp.kernel-memory" Version="0.26.0" />
       <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.1" />
       <PackageReference Include="Microsoft.KernelMemory" Version="0.98.250508.3" />
       <PackageReference Include="Microsoft.SemanticKernel.Connectors.Google" Version="1.64.0-alpha" />
diff --git a/src/MaIN.Services/Services/LLMService/LLMService.cs b/src/MaIN.Services/Services/LLMService/LLMService.cs
index b57fcb8b..df598562 100644
--- a/src/MaIN.Services/Services/LLMService/LLMService.cs
+++ b/src/MaIN.Services/Services/LLMService/LLMService.cs
@@ -239,14 +239,19 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
         var visionModel = model as IVisionModel;
         var mmProjName = visionModel?.MMProjectName
             ?? (chat.Properties.TryGetValue(ServiceConstants.Properties.MmProjNameProperty, out var p) ? p : null);
-        var llavaWeights = mmProjName is not null
-            ? await LLavaWeights.LoadFromFileAsync(ResolvePath(null, mmProjName), cancellationToken)
-            : null;
-        
-        using var executor = new BatchedExecutor(llmModel, parameters);
+
+        MtmdWeights? mtmdWeights = null;
+        if (mmProjName is not null && lastMsg.Image != null)
+        {
+            var mmProjPath = ResolvePath(null, mmProjName);
+            mtmdWeights = await MtmdWeights.LoadFromFileAsync(
+                mmProjPath, llmModel, MtmdContextParams.Default(), cancellationToken);
+        }
+
+        using var executor = new BatchedExecutor(llmModel, parameters, mtmdWeights);
 
         var (conversation, isComplete, hasFailed) = await LLMService.InitializeConversation(
-            chat, lastMsg, model, llmModel, llavaWeights, executor, cancellationToken);
+            chat, lastMsg, model, llmModel, mtmdWeights, executor, cancellationToken);
 
         if (!isComplete)
         {
@@ -271,6 +276,7 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
             }
         }
 
+        mtmdWeights?.Dispose();
         return tokens;
     }
 
@@ -294,7 +300,7 @@ private ModelParams CreateModelParameters(Chat chat, string modelKey, string? cu
         Message lastMsg,
         LocalModel model,
         LLamaWeights llmModel,
-        LLavaWeights? llavaWeights,
+        MtmdWeights? mtmdWeights,
         BatchedExecutor executor,
         CancellationToken cancellationToken)
     {
@@ -303,9 +309,9 @@ private ModelParams CreateModelParameters(Chat chat, string modelKey, string? cu
             ? executor.Create()
             : executor.Load(chat.ConversationState!);
 
-        if (lastMsg.Image != null && llavaWeights != null)
+        if (lastMsg.Image != null && mtmdWeights != null)
         {
-            await ProcessImageMessage(conversation, lastMsg, llmModel, llavaWeights, executor, cancellationToken);
+            await ProcessImageMessage(conversation, lastMsg, mtmdWeights, executor, cancellationToken);
         }
         else
         {
@@ -317,21 +323,22 @@ private ModelParams CreateModelParameters(Chat chat, string modelKey, string? cu
 
     private static async Task ProcessImageMessage(Conversation conversation,
         Message lastMsg,
-        LLamaWeights llmModel,
-        LLavaWeights? llavaWeights,
+        MtmdWeights mtmdWeights,
         BatchedExecutor executor,
         CancellationToken cancellationToken)
     {
-        var imageEmbeddings = llavaWeights?.CreateImageEmbeddings(lastMsg.Image!);
-        conversation.Prompt(imageEmbeddings!);
+        using var imageEmbed = mtmdWeights.LoadMedia(lastMsg.Image!);
+
+        var mediaMarker = NativeApi.MtmdDefaultMarker() ?? "<image>";
+        conversation.Prompt(
+            $"USER: {mediaMarker}\n{lastMsg.Content}\nASSISTANT:",
+            new ReadOnlySpan<SafeMtmdEmbed>(new[] { imageEmbed }),
+            addBos: true);
 
         while (executor.BatchedTokenCount > 0)
         {
             await executor.Infer(cancellationToken);
         }
-
-        var prompt = llmModel.Tokenize($"USER: {lastMsg.Content}\nASSISTANT:", true, false, Encoding.UTF8);
-        conversation.Prompt(prompt);
     }
 
     private static void ProcessTextMessage(Conversation conversation,

From 0264765585f01add435d143086f1f29e3efd9f4b Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Fri, 6 Mar 2026 20:20:53 +0100
Subject: [PATCH 6/9] Support custom model path and MMProj hints

Home: when a custom Model Path is set for Self backend, bake the resolved full file path into a generic local model instance so the LLMService loads from the correct location (creates GenericLocal[Vision][Reasoning]Model variants with FileName set to the resolved path). This fixes cases where Chat.Properties don't reach the service and the model file must be embedded in the model object.

Settings: add RegisteredMmProjPathHint to display the expected MMProj file path for registered local vision models (shows a "MMProj file: ..." hint derived from ResolvedModelPathPreview or fallback model directory), keeping the hint in sync with the "Will load:" preview.

LLMService: when resolving an mmproj for image models, prefer the directory of a fully-qualified modelKey (custom model file path) and fall back to the configured models path; this ensures mmproj files are located next to custom model files.
---
 .../Components/Pages/Home.razor               | 33 +++++++++++++++++++
 .../Components/Pages/Settings.razor           | 28 ++++++++++++++++
 .../Services/LLMService/LLMService.cs         |  7 +++-
 3 files changed, 67 insertions(+), 1 deletion(-)

diff --git a/src/MaIN.InferPage/Components/Pages/Home.razor b/src/MaIN.InferPage/Components/Pages/Home.razor
index bd8d73d3..9f9a7fe9 100644
--- a/src/MaIN.InferPage/Components/Pages/Home.razor
+++ b/src/MaIN.InferPage/Components/Pages/Home.razor
@@ -330,7 +330,40 @@
         if (string.IsNullOrEmpty(Utils.Model)) return null;
 
         if (ModelRegistry.TryGetById(Utils.Model, out var registeredModel))
+        {
+            // When a custom Model Path is set, bake the resolved full path into a generic
+            // model so LLMService loads from the right location. This is needed because
+            // ctx._chat (which reaches LLMService) is a separate object from Home.razor's Chat,
+            // so Chat.Properties never reach the service — the path must be in model.FileName.
+            if (Utils.BackendType == BackendType.Self && registeredModel is LocalModel localReg
+                && !string.IsNullOrEmpty(Utils.Path))
+            {
+                var fullPath = Utils.Path.EndsWith(".gguf", StringComparison.OrdinalIgnoreCase)
+                    ? Utils.Path
+                    : System.IO.Path.Combine(Utils.Path, localReg.FileName);
+
+                return localReg switch
+                {
+                    IVisionModel vm when localReg is IReasoningModel { ReasonFunction: not null } rm
+                        => new GenericLocalVisionReasoningModel(
+                            FileName: fullPath, MMProjectPath: vm.MMProjectName ?? "",
+                            ReasonFunction: rm.ReasonFunction,
+                            MaxContextWindowSize: localReg.MaxContextWindowSize),
+                    IVisionModel vm
+                        => new GenericLocalVisionModel(
+                            FileName: fullPath, MMProjectPath: vm.MMProjectName ?? "",
+                            MaxContextWindowSize: localReg.MaxContextWindowSize),
+                    IReasoningModel { ReasonFunction: not null } rm
+                        => new GenericLocalReasoningModel(
+                            FileName: fullPath, ReasonFunction: rm.ReasonFunction,
+                            MaxContextWindowSize: localReg.MaxContextWindowSize),
+                    _ => new GenericLocalModel(
+                            FileName: fullPath,
+                            MaxContextWindowSize: localReg.MaxContextWindowSize)
+                };
+            }
             return registeredModel;
+        }
 
         // Self = local GGUF file; Ollama Local is an HTTP server, not a file path
         if (Utils.BackendType == BackendType.Self)
diff --git a/src/MaIN.InferPage/Components/Pages/Settings.razor b/src/MaIN.InferPage/Components/Pages/Settings.razor
index 3a60a2b4..c6d5456f 100644
--- a/src/MaIN.InferPage/Components/Pages/Settings.razor
+++ b/src/MaIN.InferPage/Components/Pages/Settings.razor
@@ -102,6 +102,10 @@
                                 <span class="no-capabilities">No special capabilities</span>
                             }
                         </div>
+                        @if (RegisteredMmProjPathHint is { } mmProjHint)
+                        {
+                            <span class="api-key-hint">MMProj file: @mmProjHint</span>
+                        }
                     }
                     else
                     {
@@ -201,6 +205,30 @@
     private bool _detectedReasoning;
     private bool _detectedImageGen;
 
+    // Shows expected MMProj file path for registered local vision models.
+    // Derives the directory from ResolvedModelPathPreview so it always stays in sync
+    // with the "Will load:" hint (including any custom Model Path the user typed).
+    private string? RegisteredMmProjPathHint
+    {
+        get
+        {
+            if (_selectedBackend?.BackendType != BackendType.Self || !_isRegisteredModel) return null;
+            if (!_detectedVision) return null;
+            if (string.IsNullOrWhiteSpace(_modelName)) return null;
+            if (!ModelRegistry.TryGetById(_modelName, out var aiModel) || aiModel is not LocalModel localModel) return null;
+            if (localModel is not IVisionModel visionModel || visionModel.MMProjectName is not { } mmProjName) return null;
+
+            // Reuse the already-resolved model file path to derive the directory,
+            // so changes to the Model Path field are immediately reflected here too.
+            var modelFilePath = ResolvedModelPathPreview;
+            var dir = modelFilePath != null
+                ? (Path.GetDirectoryName(modelFilePath) ?? "")
+                : (MaINSettings.ModelsPath ?? Environment.GetEnvironmentVariable("MaIN_ModelsPath") ?? "");
+
+            return string.IsNullOrEmpty(dir) ? mmProjName : Path.Combine(dir, mmProjName);
+        }
+    }
+
     // Manual capability selection (unregistered models)
     private bool _manualVision;
     private bool _manualReasoning;
diff --git a/src/MaIN.Services/Services/LLMService/LLMService.cs b/src/MaIN.Services/Services/LLMService/LLMService.cs
index df598562..e75ffa14 100644
--- a/src/MaIN.Services/Services/LLMService/LLMService.cs
+++ b/src/MaIN.Services/Services/LLMService/LLMService.cs
@@ -243,7 +243,12 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
         MtmdWeights? mtmdWeights = null;
         if (mmProjName is not null && lastMsg.Image != null)
         {
-            var mmProjPath = ResolvePath(null, mmProjName);
+            // When the model file is at a custom location (fully-qualified path),
+            // look for the mmproj in the same directory. Otherwise fall back to modelsPath.
+            var mmProjDir = Path.IsPathFullyQualified(modelKey)
+                ? Path.GetDirectoryName(modelKey)
+                : null;
+            var mmProjPath = ResolvePath(mmProjDir, mmProjName);
             mtmdWeights = await MtmdWeights.LoadFromFileAsync(
                 mmProjPath, llmModel, MtmdContextParams.Default(), cancellationToken);
         }

From 42c52c8207976a568de4c9a436a459e2ad0cc73b Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Fri, 13 Mar 2026 21:39:28 +0100
Subject: [PATCH 7/9] CR 1

---
 src/MaIN.Core/.nuspec | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/MaIN.Core/.nuspec b/src/MaIN.Core/.nuspec
index 80867d51..01310416 100644
--- a/src/MaIN.Core/.nuspec
+++ b/src/MaIN.Core/.nuspec
@@ -13,9 +13,9 @@
     <dependencies>
       <dependency id="GTranslate" version="2.3.1" />
       <dependency id="HtmlAgilityPack" version="1.12.4" />
-      <dependency id="LLamaSharp" version="0.25.0" />
-      <dependency id="LLamaSharp.Backend.Cuda12" version="0.25.0" />
-      <dependency id="LLamaSharp.kernel-memory" version="0.25.0" />
+      <dependency id="LLamaSharp" version="0.26.0" />
+      <dependency id="LLamaSharp.Backend.Cuda12" version="0.26.0" />
+      <dependency id="LLamaSharp.kernel-memory" version="0.26.0" />
       <dependency id="ModelContextProtocol.AspNetCore" version="0.2.0-preview.1" />
       <dependency id="Microsoft.SemanticKernel" version="1.68.0" />
       <dependency id="Microsoft.SemanticKernel.Connectors.Google" version="1.64.0-alpha" />

From e3c9b047783bf5fb50cfd5ed4b5484f861b4d4f8 Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Fri, 13 Mar 2026 21:43:15 +0100
Subject: [PATCH 8/9] versioning

---
 Releases/0.10.1.md    | 5 +++++
 src/MaIN.Core/.nuspec | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 Releases/0.10.1.md

diff --git a/Releases/0.10.1.md b/Releases/0.10.1.md
new file mode 100644
index 00000000..7574c9b1
--- /dev/null
+++ b/Releases/0.10.1.md
@@ -0,0 +1,5 @@
+# 0.10.1 release
+
+- Added InferPage Settings with backend selection, model configuration, API keys, and per-backend profiles.
+- Added custom model paths and multimodal (.mmproj) support for local vision models.
+- Refactored settings logic and upgraded LLamaSharp to 0.26.0 for improved vision reliability.
\ No newline at end of file
diff --git a/src/MaIN.Core/.nuspec b/src/MaIN.Core/.nuspec
index 01310416..91376edf 100644
--- a/src/MaIN.Core/.nuspec
+++ b/src/MaIN.Core/.nuspec
@@ -2,7 +2,7 @@
 <package>
   <metadata>
     <id>MaIN.NET</id>
-    <version>0.10.0</version>
+    <version>0.10.1</version>
     <authors>Wisedev</authors>
     <owners>Wisedev</owners>
     <icon>favicon.png</icon>

From 59ffde4d86d8e39aec2cda4f9524327d712d9e7c Mon Sep 17 00:00:00 2001
From: Magdalena Majta <majta.magdalena@gmail.com>
Date: Fri, 13 Mar 2026 22:31:53 +0100
Subject: [PATCH 9/9] CR 2 - Make settings dialog responsive

Update settings dialog sizing in src/MaIN.InferPage/wwwroot/settings.css to use viewport-based width and constraints: set width to 40vw with a min-width of 480px and max-width 90vw, and increase max-height from 85vh to 95vh. This improves layout and usability across different screen sizes.
---
 src/MaIN.InferPage/wwwroot/settings.css | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/MaIN.InferPage/wwwroot/settings.css b/src/MaIN.InferPage/wwwroot/settings.css
index c0807cda..c802c3ca 100644
--- a/src/MaIN.InferPage/wwwroot/settings.css
+++ b/src/MaIN.InferPage/wwwroot/settings.css
@@ -16,9 +16,10 @@
     background: var(--neutral-layer-1);
     border-radius: 12px;
     box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
-    width: 480px;
+    width: 40vw;
+    min-width: 480px;
     max-width: 90vw;
-    max-height: 85vh;
+    max-height: 95vh;
     overflow-y: auto;
     display: flex;
     flex-direction: column;