superlocalmemory 3.4.23 → 3.4.24

package/src/superlocalmemory/server/routes/v3_api.py

@@ -129,6 +129,11 @@ async def set_mode(request: Request):
             llm_model=old_config.llm.model,
             llm_api_key=old_config.llm.api_key,
             llm_api_base=old_config.llm.api_base,
+            embedding_provider=old_config.embedding.provider,
+            embedding_endpoint=old_config.embedding.api_endpoint,
+            embedding_key=old_config.embedding.api_key,
+            embedding_model_name=old_config.embedding.model_name,
+            embedding_dimension=old_config.embedding.dimension,
         )
         new_config.active_profile = old_config.active_profile
         new_config.save()
@@ -165,7 +170,10 @@ async def set_mode(request: Request):
 
 @router.post("/mode/set")
 async def set_full_config(request: Request):
-    """Save mode + provider + model + API key together."""
+    """Save mode + provider + model + API key together.
+
+    V3.4.24: Also accepts embedding_* fields for custom embedding endpoints.
+    """
     try:
         body = await request.json()
         new_mode = body.get("mode", "a").lower()
@@ -187,6 +195,11 @@ async def set_full_config(request: Request):
             llm_model=model,
             llm_api_key=api_key,
             llm_api_base="http://localhost:11434" if provider == "ollama" else "",
+            embedding_provider=body.get("embedding_provider", ""),
+            embedding_endpoint=body.get("embedding_endpoint", ""),
+            embedding_key=body.get("embedding_key", ""),
+            embedding_model_name=body.get("embedding_model", ""),
+            embedding_dimension=int(body.get("embedding_dimension", 0) or 0),
         )
         config.active_profile = old.active_profile
         config.save()
@@ -213,11 +226,145 @@ async def set_full_config(request: Request):
             "mode": new_mode,
             "provider": provider,
             "model": model,
+            "embedding_provider": config.embedding.provider,
+            "embedding_model": config.embedding.model_name,
+            "embedding_dimension": config.embedding.dimension,
+        }
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+# ── V3.4.24: Embedding Configuration ────────────────────────────────
+
+@router.get("/embedding/config")
+async def get_embedding_config(request: Request):
+    """Return current embedding configuration."""
+    try:
+        from superlocalmemory.core.config import SLMConfig
+        config = SLMConfig.load()
+        emb = config.embedding
+        return {
+            "provider": emb.provider,
+            "model_name": emb.model_name,
+            "dimension": emb.dimension,
+            "api_endpoint": emb.api_endpoint,
+            "has_key": bool(emb.api_key),
+            "is_openai_compatible": emb.is_openai_compatible,
+            "mode": config.mode.value,
+        }
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
+@router.put("/embedding/config")
+async def set_embedding_config(request: Request):
+    """Update embedding configuration independently of mode switch."""
+    try:
+        body = await request.json()
+        from superlocalmemory.core.config import SLMConfig, EmbeddingConfig
+        config = SLMConfig.load()
+
+        new_provider = body.get("provider", config.embedding.provider)
+        new_model = body.get("model_name", config.embedding.model_name)
+        new_dim = int(body.get("dimension", config.embedding.dimension) or 768)
+        if not (64 <= new_dim <= 8192):
+            return JSONResponse({"error": f"Dimension must be 64-8192, got {new_dim}"}, status_code=400)
+        new_endpoint = body.get("api_endpoint", config.embedding.api_endpoint)
+        new_key = body.get("api_key", config.embedding.api_key)
+
+        old_emb = config.embedding
+        config.embedding = EmbeddingConfig(
+            model_name=new_model,
+            dimension=new_dim,
+            provider=new_provider,
+            api_endpoint=new_endpoint,
+            api_key=new_key,
+            ollama_model=old_emb.ollama_model,
+            ollama_base_url=old_emb.ollama_base_url,
+            api_version=old_emb.api_version,
+            deployment_name=old_emb.deployment_name,
+        )
+        config.save()
+
+        needs_reindex = (
+            old_emb.provider != new_provider
+            or old_emb.model_name != new_model
+            or old_emb.dimension != new_dim
+        )
+
+        # Kill workers so next request uses new config
+        try:
+            from superlocalmemory.core.worker_pool import WorkerPool
+            WorkerPool.shared().shutdown()
+        except Exception:
+            pass
+        if hasattr(request.app.state, "engine"):
+            request.app.state.engine = None
+
+        return {
+            "success": True,
+            "provider": new_provider,
+            "model_name": new_model,
+            "dimension": new_dim,
+            "needs_reindex": needs_reindex,
         }
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
 
 
+@router.post("/embedding/test")
+async def test_embedding_endpoint(request: Request):
+    """Test connectivity to a custom embedding endpoint."""
+    try:
+        import httpx
+        from urllib.parse import urlparse
+        body = await request.json()
+        endpoint = body.get("api_endpoint", "").rstrip("/")
+        model = body.get("model_name", "test")
+        api_key = body.get("api_key", "")
+
+        if not endpoint:
+            return JSONResponse({"error": "No endpoint provided"}, status_code=400)
+
+        parsed = urlparse(endpoint)
+        if parsed.scheme not in ("http", "https"):
+            return JSONResponse({"error": "Only http/https endpoints supported"}, status_code=400)
+        host = parsed.hostname or ""
+        if host in ("169.254.169.254", "metadata.google.internal"):
+            return JSONResponse({"error": "Cloud metadata endpoints not allowed"}, status_code=400)
+
+        if not endpoint.endswith("/embeddings"):
+            endpoint = f"{endpoint}/embeddings"
+
+        headers = {"Content-Type": "application/json"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        payload = {"input": ["test embedding connection"], "model": model}
+
+        with httpx.Client(timeout=httpx.Timeout(15.0)) as client:
+            resp = client.post(endpoint, headers=headers, json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+            emb_data = data.get("data", [])
+            if emb_data:
+                dim = len(emb_data[0].get("embedding", []))
+                return {
+                    "success": True,
+                    "message": f"Connected! Dimension: {dim}",
+                    "dimension": dim,
+                }
+            return {"success": False, "error": "No embedding data returned"}
+    except httpx.HTTPStatusError as e:
+        return {"success": False, "error": f"HTTP {e.response.status_code}"}
+    except httpx.ConnectError:
+        return {"success": False, "error": "Cannot reach the embedding server. Is it running?"}
+    except httpx.TimeoutException:
+        return {"success": False, "error": "Connection timed out after 15 seconds."}
+    except Exception as e:
+        return {"success": False, "error": type(e).__name__}
+
+
 @router.post("/provider/test")
 async def test_provider(request: Request):
     """Test connectivity to an LLM provider."""
@@ -1593,13 +1740,8 @@ async def process_health(request: Request):
         processes["worker_pool"] = {"status": worker_status}
 
         # Memory usage of current process (approximate)
-        memory_mb = 0.0
-        try:
-            import resource
-            usage = resource.getrusage(resource.RUSAGE_SELF)
-            memory_mb = round(usage.ru_maxrss / (1024 * 1024), 1)
-        except Exception:
-            pass
+        from superlocalmemory.core.platform_utils import get_rss_mb
+        memory_mb = round(get_rss_mb(), 1)
 
         return {
             "processes": processes,

package/src/superlocalmemory/ui/index.html

@@ -1007,8 +1007,53 @@
                             </div>
                         </div>
 
+                        <!-- Step 3: Embedding Configuration (V3.4.24) -->
+                        <div class="mt-3 pt-3 border-top" id="settings-embedding-panel">
+                            <h6 class="text-muted"><i class="bi bi-cpu"></i> Step 3: Embedding Model</h6>
+                            <p class="small text-muted mb-2">
+                                Controls how text is converted to vectors for semantic search.
+                                Default: local model (768d). Custom: any OpenAI-compatible endpoint.
+                            </p>
+                            <div class="row g-2 mb-2">
+                                <div class="col-md-4">
+                                    <label class="form-label small">Embedding Provider</label>
+                                    <select class="form-select form-select-sm" id="settings-emb-provider">
+                                        <option value="default">Default (Local Model)</option>
+                                        <option value="openai">Custom Endpoint (OpenAI-compatible)</option>
+                                    </select>
+                                </div>
+                                <div class="col-md-4" id="settings-emb-model-col" style="display:none;">
+                                    <label class="form-label small">Model Name</label>
+                                    <input type="text" id="settings-emb-model" class="form-control form-control-sm" placeholder="e.g. Qwen3-Embedding">
+                                </div>
+                                <div class="col-md-4" id="settings-emb-dim-col" style="display:none;">
+                                    <label class="form-label small">Dimension</label>
+                                    <input type="number" id="settings-emb-dimension" class="form-control form-control-sm" placeholder="e.g. 1024" min="64" max="8192">
+                                </div>
+                            </div>
+                            <div class="row g-2 mb-2" id="settings-emb-endpoint-row" style="display:none;">
+                                <div class="col-md-8">
+                                    <label class="form-label small">Embedding Endpoint</label>
+                                    <input type="text" id="settings-emb-endpoint" class="form-control form-control-sm" placeholder="http://localhost:8045/v1/embeddings">
+                                </div>
+                                <div class="col-md-4">
+                                    <label class="form-label small">API Key (optional)</label>
+                                    <input type="password" id="settings-emb-key" class="form-control form-control-sm" placeholder="not-needed">
+                                </div>
+                            </div>
+                            <div id="settings-emb-test-row" style="display:none;">
+                                <button class="btn btn-sm btn-outline-info" id="settings-emb-test-btn">
+                                    <i class="bi bi-lightning"></i> Test Embedding
+                                </button>
+                                <span id="settings-emb-test-result" class="ms-2 small"></span>
+                            </div>
+                            <div id="settings-emb-info" class="small text-muted mt-1">
+                                Using local <strong>nomic-embed-text-v1.5</strong> (768d)
+                            </div>
+                        </div>
+
                         <!-- Save button -->
-                        <div class="mt-2">
+                        <div class="mt-3">
                             <button class="btn btn-primary" id="settings-save-all">
                                 <i class="bi bi-check-circle"></i> Save Configuration
                             </button>

package/src/superlocalmemory/ui/js/auto-settings.js

@@ -353,20 +353,28 @@ async function saveAllSettings() {
     if (statusEl) { statusEl.textContent = 'Saving...'; statusEl.style.display = 'inline'; statusEl.className = 'ms-2 text-muted'; }
 
     try {
-        // Save mode
+        // V3.4.24: Include embedding params in save payload
+        var embParams = getEmbeddingParams();
+        var payload = Object.assign({mode: mode, provider: provider, model: model, api_key: apiKey}, embParams);
         var modeResp = await fetch('/api/v3/mode/set', {
             method: 'POST',
             headers: {'Content-Type': 'application/json'},
-            body: JSON.stringify({mode: mode, provider: provider, model: model, api_key: apiKey})
+            body: JSON.stringify(payload)
         });
 
         if (modeResp.ok) {
+            var modeData = await modeResp.json();
+            var msg = 'Configuration saved! Mode: ' + mode.toUpperCase() +
+                (provider !== 'none' ? ' | Provider: ' + provider : '');
+            if (modeData.needs_reindex) {
+                msg += ' | Embeddings will be re-indexed on next use (may take several minutes).';
+            }
             if (statusEl) {
-                statusEl.textContent = 'Configuration saved! Mode: ' + mode.toUpperCase() +
-                    (provider !== 'none' ? ' | Provider: ' + provider : '');
-                statusEl.className = 'ms-2 text-success fw-bold';
+                statusEl.textContent = msg;
+                statusEl.className = modeData.needs_reindex ? 'ms-2 text-warning fw-bold' : 'ms-2 text-success fw-bold';
             }
             loadModeSettings();
+            loadEmbeddingSettings();
         } else {
             if (statusEl) { statusEl.textContent = 'Save failed'; statusEl.className = 'ms-2 text-danger'; }
         }
@@ -381,10 +389,127 @@ async function saveAllSettings() {
     }, 5000);
 }
 
+// ============================================================================
+// Embedding Configuration (V3.4.24 — Custom OpenAI-compatible endpoints)
+// ============================================================================
+
+async function loadEmbeddingSettings() {
+    try {
+        var resp = await fetch('/api/v3/embedding/config');
+        if (!resp.ok) return;
+        var data = await resp.json();
+
+        var provEl = document.getElementById('settings-emb-provider');
+        if (provEl) {
+            provEl.value = data.is_openai_compatible ? 'openai' : 'default';
+        }
+
+        if (data.is_openai_compatible) {
+            var modelEl = document.getElementById('settings-emb-model');
+            if (modelEl) modelEl.value = data.model_name || '';
+            var dimEl = document.getElementById('settings-emb-dimension');
+            if (dimEl) dimEl.value = data.dimension || '';
+            var epEl = document.getElementById('settings-emb-endpoint');
+            if (epEl) epEl.value = data.api_endpoint || '';
+        }
+
+        updateEmbeddingUI();
+
+        var info = document.getElementById('settings-emb-info');
+        if (info) {
+            var _name = (data.model_name || 'unknown').replace(/[<>&"']/g, function(c) {
+                return {'<':'&lt;','>':'&gt;','&':'&amp;','"':'&quot;',"'":'&#39;'}[c];
+            });
+            if (data.is_openai_compatible) {
+                info.innerHTML = 'Using custom endpoint: <strong>' + _name + '</strong> (' + data.dimension + 'd)';
+            } else {
+                info.innerHTML = 'Using local <strong>' + _name + '</strong> (' + data.dimension + 'd)';
+            }
+        }
+    } catch (e) {
+        console.log('Load embedding settings error:', e);
+    }
+}
+
+function updateEmbeddingUI() {
+    var provider = document.getElementById('settings-emb-provider')?.value || 'default';
+    var isCustom = provider === 'openai';
+
+    var modelCol = document.getElementById('settings-emb-model-col');
+    var dimCol = document.getElementById('settings-emb-dim-col');
+    var endpointRow = document.getElementById('settings-emb-endpoint-row');
+    var testRow = document.getElementById('settings-emb-test-row');
+
+    if (modelCol) modelCol.style.display = isCustom ? 'block' : 'none';
+    if (dimCol) dimCol.style.display = isCustom ? 'block' : 'none';
+    if (endpointRow) endpointRow.style.display = isCustom ? 'flex' : 'none';
+    if (testRow) testRow.style.display = isCustom ? 'block' : 'none';
+
+    var info = document.getElementById('settings-emb-info');
+    if (info && !isCustom) {
+        info.innerHTML = 'Using local <strong>nomic-embed-text-v1.5</strong> (768d)';
+    }
+}
+
+async function testEmbeddingEndpoint() {
+    var endpoint = document.getElementById('settings-emb-endpoint')?.value || '';
+    var model = document.getElementById('settings-emb-model')?.value || '';
+    var key = document.getElementById('settings-emb-key')?.value || '';
+    var resultEl = document.getElementById('settings-emb-test-result');
+
+    if (!endpoint) {
+        if (resultEl) { resultEl.textContent = 'Enter an endpoint first'; resultEl.className = 'ms-2 small text-danger'; }
+        return;
+    }
+
+    if (resultEl) { resultEl.textContent = 'Testing...'; resultEl.className = 'ms-2 small text-muted'; }
+
+    try {
+        var resp = await fetch('/api/v3/embedding/test', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({api_endpoint: endpoint, model_name: model, api_key: key})
+        });
+        var data = await resp.json();
+        if (data.success) {
+            if (resultEl) { resultEl.textContent = data.message; resultEl.className = 'ms-2 small text-success fw-bold'; }
+            var dimEl = document.getElementById('settings-emb-dimension');
+            if (dimEl && data.dimension) {
+                if (!dimEl.value) {
+                    dimEl.value = data.dimension;
+                } else if (parseInt(dimEl.value) !== data.dimension) {
+                    if (resultEl) {
+                        resultEl.textContent = 'Connected! Warning: endpoint returns ' + data.dimension + 'd but you entered ' + dimEl.value + 'd';
+                        resultEl.className = 'ms-2 small text-warning fw-bold';
+                    }
+                }
+            }
+        } else {
+            if (resultEl) { resultEl.textContent = 'Failed: ' + (data.error || 'Unknown'); resultEl.className = 'ms-2 small text-danger'; }
+        }
+    } catch (e) {
+        if (resultEl) { resultEl.textContent = 'Error: ' + e.message; resultEl.className = 'ms-2 small text-danger'; }
+    }
+}
+
+function getEmbeddingParams() {
+    var provider = document.getElementById('settings-emb-provider')?.value || 'default';
+    if (provider !== 'openai') return {};
+    return {
+        embedding_provider: 'openai',
+        embedding_endpoint: document.getElementById('settings-emb-endpoint')?.value || '',
+        embedding_model: document.getElementById('settings-emb-model')?.value || '',
+        embedding_dimension: parseInt(document.getElementById('settings-emb-dimension')?.value) || 0,
+        embedding_key: document.getElementById('settings-emb-key')?.value || '',
+    };
+}
+
 // Bind events
 document.getElementById('settings-provider')?.addEventListener('change', updateProviderUI);
 document.getElementById('settings-save-all')?.addEventListener('click', saveAllSettings);
 document.getElementById('settings-test-btn')?.addEventListener('click', testConnection);
+document.getElementById('settings-emb-provider')?.addEventListener('change', updateEmbeddingUI);
+document.getElementById('settings-emb-test-btn')?.addEventListener('click', testEmbeddingEndpoint);
 
 // Mode radio buttons
 document.querySelectorAll('input[name="settings-mode-radio"]').forEach(function(radio) {
@@ -395,5 +520,6 @@ document.querySelectorAll('input[name="settings-mode-radio"]').forEach(function(
 document.getElementById('settings-tab')?.addEventListener('shown.bs.tab', function() {
     loadAutoSettings();
     loadModeSettings();
+    loadEmbeddingSettings();
     updateModeUI();
 });