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 80867d51..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>
@@ -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" />
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.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/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..63c6e373 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="@(() => SettingsState.RequestSettings())" 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"
@@ -64,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)
     {
@@ -72,22 +79,21 @@
         {
             var stored = await JS.InvokeAsync<string>("themeManager.load");
             Mode = stored == "dark" ? DesignThemeModes.Dark : DesignThemeModes.Light;
+            SettingsState.OnSettingsApplied += OnSettingsChanged;
             StateHasChanged();
         }
     }
 
-    private void SetTheme()
+    private void OnSettingsChanged()
     {
-        if (_isChangingTheme) return;
-        _isChangingTheme = true;
-        Mode = Mode == DesignThemeModes.Dark ? DesignThemeModes.Light : DesignThemeModes.Dark;
-        _isChangingTheme = false;
+        InvokeAsync(StateHasChanged);
     }
 
-    private void Reload(MouseEventArgs obj)
-    {
-        _navigationManager.Refresh(true);
-    }
+    private void SetTheme()
+        => Mode = Mode == DesignThemeModes.Dark ? DesignThemeModes.Light : DesignThemeModes.Dark;
+
+    private void Reload()
+        => _navigationManager.Refresh(true);
 
     private string GetBackendColor()
     {
@@ -103,4 +109,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..9f9a7fe9 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
@@ -9,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
@@ -18,6 +23,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 +216,8 @@
 </div>
 
 @code {
+    private bool _showSettings;
+    private bool _hasExistingConfig;
     private bool _isLoading;
     private bool _isThinking;
     private bool _isDragging;
@@ -214,7 +228,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 +257,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 +292,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 +323,137 @@
         {
             _errorMessage = ex.Message;
         }
+    }
 
-        return base.OnInitializedAsync();
+    private AIModel? ResolveModel()
+    {
+        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)
+        {
+            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,
+            settings.MmProjName,
+            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)
@@ -325,6 +496,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));
@@ -371,6 +547,11 @@
 
             if (ImageExtensions.Contains(extension.ToLowerInvariant()))
             {
+                if (!Utils.Vision)
+                {
+                    _errorMessage = "This model doesn't support image input.";
+                    return;
+                }
                 _selectedImages.Add((fileInfo, base64Data));
             }
             else
@@ -447,6 +628,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();
@@ -635,6 +821,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..c6d5456f
--- /dev/null
+++ b/src/MaIN.InferPage/Components/Pages/Settings.razor
@@ -0,0 +1,479 @@
+@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>
+                        @if (RegisteredMmProjPathHint is { } mmProjHint)
+                        {
+                            <span class="api-key-hint">MMProj file: @mmProjHint</span>
+                        }
+                    }
+                    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>
+            }
+
+            @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">
+            <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;
+
+    // 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;
+    private bool _manualImageGen;
+    private string? _mmProjName;
+
+    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()
+    {
+        _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)
+         .Prepend(new BackendOption(0, "Local", BackendType.Self, false))
+         .ToList();
+
+        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;
+            _mmProjName = settings.MmProjName;
+
+            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 profile = await SettingsStorage.GetProfileForBackendAsync(backendKey);
+        if (profile != null)
+        {
+            _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;
+                _mmProjName      = profile.MmProjName;
+            }
+        }
+        else
+        {
+            // Fallback: old model-history entry (no capability info)
+            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,
+            MmProjName = _mmProjName
+        };
+        await SettingsStorage.SaveSettingsAsync(settings);
+
+        await SettingsStorage.SaveProfileForBackendAsync(
+            backendKey, _modelName, hasVision, hasReasoning, hasImageGen, _mmProjName);
+
+        // 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,
+            _mmProjName,
+            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..86728b75 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,23 +100,19 @@
     return;
 }
 
-if (Utils.BackendType != BackendType.Self)
+// For Self backend CLI mode, validate model before registering
+if (!Utils.NeedsConfiguration && Utils.BackendType == BackendType.Self
+    && Utils.Path == null && !ModelRegistry.Exists(Utils.Model!))
 {
-    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();
 
@@ -122,4 +130,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..48bddd4c
--- /dev/null
+++ b/src/MaIN.InferPage/Services/InferPageSettings.cs
@@ -0,0 +1,13 @@
+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; }
+    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
new file mode 100644
index 00000000..db52934c
--- /dev/null
+++ b/src/MaIN.InferPage/Services/SettingsService.cs
@@ -0,0 +1,58 @@
+using Microsoft.JSInterop;
+
+namespace MaIN.InferPage.Services;
+
+public class SettingsService(IJSRuntime js)
+{
+    private const string SettingsKey = "inferpage-settings";
+    private const string ApiKeysKey = "inferpage-apikeys";
+    private const string ModelHistoryKey = "inferpage-model-history";
+
+    public async Task<InferPageSettings?> LoadSettingsAsync()
+        => 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()
+        => await js.InvokeAsync<bool>("settingsManager.exists", SettingsKey);
+
+    public Task SaveApiKeyAsync(string backend, string key) => SetInDictAsync(ApiKeysKey, backend, key);
+    public Task<string?> GetApiKeyForBackendAsync(string backend) => GetFromDictAsync(ApiKeysKey, backend);
+
+    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, string? mmProjName = null)
+    {
+        var profiles = await js.InvokeAsync<Dictionary<string, BackendProfile>?>(
+            "settingsManager.load", BackendProfilesKey) ?? new();
+        profiles[backend] = new BackendProfile(model, vision, reasoning, imageGen, mmProjName);
+        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);
+        dict[key] = value;
+        await js.InvokeVoidAsync("settingsManager.save", storageKey, dict);
+    }
+
+    private async Task<string?> GetFromDictAsync(string storageKey, string key)
+        => (await LoadDictAsync(storageKey)).GetValueOrDefault(key);
+
+    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, string? MmProjName = null);
diff --git a/src/MaIN.InferPage/Services/SettingsStateService.cs b/src/MaIN.InferPage/Services/SettingsStateService.cs
new file mode 100644
index 00000000..f6da3fb6
--- /dev/null
+++ b/src/MaIN.InferPage/Services/SettingsStateService.cs
@@ -0,0 +1,18 @@
+namespace MaIN.InferPage.Services;
+
+/// <summary>Event bus for NavBar ↔ Home sibling communication.</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..49c297b5 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;
 
@@ -10,37 +11,84 @@ 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 bool Reason
+    public static string? Model;
+
+    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 string? MmProjName { get; set; }
+
+    // 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 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);
+
+    public static void ApplySettings(
+        BackendType backendType,
+        string model,
+        string? modelPath,
+        bool hasVision,
+        bool hasReasoning,
+        bool hasImageGen,
+        string? mmProjName,
+        MaINSettings mainSettings,
+        string? apiKey)
     {
-        get
+        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))
         {
-            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
-            return false;
+            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;
         }
-    }
-
-    public static bool ImageGen
-    {
-        get
+        else
         {
-            if (string.IsNullOrEmpty(Model)) return false;
-            if (ModelRegistry.TryGetById(Model, out var m))
-                return m is IImageGenerationModel;
-            return ImageGenerationModels.Contains(Model); // fallback for unregistered models (e.g. FLUX via separate server)
+            Path = null;
         }
-    }
+        HasApiKey = !string.IsNullOrEmpty(apiKey);
+        NeedsConfiguration = false;
 
-    public static bool Vision
-    {
-        get
+        ManualVision = hasVision;
+        ManualReasoning = hasReasoning;
+        ManualImageGen = hasImageGen;
+        MmProjName = string.IsNullOrWhiteSpace(mmProjName) ? null : mmProjName.Trim();
+
+        mainSettings.BackendType = backendType;
+
+        // 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)
         {
-            if (string.IsNullOrEmpty(Model)) return false;
-            if (ModelRegistry.TryGetById(Model, out var m))
-                return m is IVisionModel;
-            return VisionModels.Contains(Model); // fallback for unregistered models
+            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;
         }
     }
 
@@ -73,4 +121,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..c802c3ca
--- /dev/null
+++ b/src/MaIN.InferPage/wwwroot/settings.css
@@ -0,0 +1,117 @@
+.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: 40vw;
+    min-width: 480px;
+    max-width: 90vw;
+    max-height: 95vh;
+    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/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/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/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/LLMService.cs b/src/MaIN.Services/Services/LLMService/LLMService.cs
index 2591e8a3..e75ffa14 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);
@@ -73,7 +75,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 +110,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,
@@ -235,14 +237,26 @@ 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(Path.Combine(modelsPath, visionModel.MMProjectName), cancellationToken)
-            : null;
-        
-        using var executor = new BatchedExecutor(llmModel, parameters);
+        var mmProjName = visionModel?.MMProjectName
+            ?? (chat.Properties.TryGetValue(ServiceConstants.Properties.MmProjNameProperty, out var p) ? p : null);
+
+        MtmdWeights? mtmdWeights = null;
+        if (mmProjName is not null && lastMsg.Image != null)
+        {
+            // 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);
+        }
+
+        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)
         {
@@ -267,12 +281,13 @@ private async Task<List<LLMTokenValue>> ProcessChatRequest(
             }
         }
 
+        mtmdWeights?.Dispose();
         return tokens;
     }
 
     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,
@@ -290,7 +305,7 @@ private ModelParams CreateModelParameters(Chat chat, string modelKey, string? cu
         Message lastMsg,
         LocalModel model,
         LLamaWeights llmModel,
-        LLavaWeights? llavaWeights,
+        MtmdWeights? mtmdWeights,
         BatchedExecutor executor,
         CancellationToken cancellationToken)
     {
@@ -299,9 +314,9 @@ private ModelParams CreateModelParameters(Chat chat, string modelKey, string? cu
             ? executor.Create()
             : executor.Load(chat.ConversationState!);
 
-        if (lastMsg.Image != null)
+        if (lastMsg.Image != null && mtmdWeights != null)
         {
-            await ProcessImageMessage(conversation, lastMsg, llmModel, llavaWeights, executor, cancellationToken);
+            await ProcessImageMessage(conversation, lastMsg, mtmdWeights, executor, cancellationToken);
         }
         else
         {
@@ -313,21 +328,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,
@@ -500,25 +516,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)
     {
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;
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>