superlocalmemory 3.4.54 → 3.4.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.54",
+  "version": "3.4.55",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.54"
+version = "3.4.55"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/scripts/install.sh

@@ -239,11 +239,63 @@ if [ -f "${REPO_DIR}/mcp_server.py" ]; then
     echo "✓ MCP server copied"
 fi
 
-# Copy config if not exists
-if [ ! -f "${INSTALL_DIR}/config.json" ]; then
-    echo "Creating default config..."
-    cp "${REPO_DIR}/config.json" "${INSTALL_DIR}/config.json"
-    echo "✓ Config created"
+# Interactive mode selection (v3.4.55)
+if [ ! -f "${INSTALL_DIR}/current_mode" ] && [ "${NON_INTERACTIVE}" != "true" ]; then
+    echo ""
+    echo "┌─────────────────────────────────────────────┐"
+    echo "│         SuperLocalMemory V3 — Setup         │"
+    echo "└─────────────────────────────────────────────┘"
+    echo ""
+    echo "  Choose operating mode:"
+    echo ""
+    echo "    [A] Zero-Cloud — Pure local, no API keys needed"
+    echo "        • Embedding: sentence-transformers (local)"
+    echo "        • LLM: none"
+    echo "        • Best for: privacy, air-gapped, EU AI Act"
+    echo ""
+    echo "    [B] Local AI — Ollama-powered (recommended)"
+    echo "        • Embedding: ollama / nomic-embed-text"
+    echo "        • LLM: ollama / llama3.2"
+    echo "        • Best for: full offline AI, zero cost"
+    echo ""
+    echo "    [C] Cloud Power — OpenRouter / OpenAI API"
+    echo "        • Embedding: text-embedding-3-large"
+    echo "        • LLM: claude-sonnet-4 / gpt-4.1-mini"
+    echo "        • Best for: max quality, API required"
+    echo ""
+    read -r -p "  Enter mode [A/B/C] (default: B): " MODE_CHOICE
+    MODE_CHOICE=${MODE_CHOICE:-b}
+    case "${MODE_CHOICE,,}" in
+        a) SELECTED_MODE="a" ;;
+        c) SELECTED_MODE="c" ;;
+        *) SELECTED_MODE="b" ;;
+    esac
+    echo ""
+    echo "  → Selected Mode ${SELECTED_MODE^^}"
+    echo ""
+    # Generate initial 3-mode config via Python
+    python3 -c "
+from superlocalmemory.core.config import SLMConfig
+SLMConfig.migrate_to_3mode()
+SLMConfig.switch_mode('${SELECTED_MODE}')
+print('✓ Mode ${SELECTED_MODE^^} configured')
+print('  Config files created: mode_a.json, mode_b.json, mode_c.json')
+print('  Run slm mode a/b/c to switch modes later')
+"
+elif [ ! -f "${INSTALL_DIR}/config.json" ] && [ "${NON_INTERACTIVE}" = "true" ]; then
+    echo "Creating default config (non-interactive, Mode B)..."
+    python3 -c "
+from superlocalmemory.core.config import SLMConfig
+SLMConfig.migrate_to_3mode()
+print('✓ Default config created (Mode B)')
+"
+elif [ -f "${INSTALL_DIR}/config.json" ] && [ ! -f "${INSTALL_DIR}/current_mode" ]; then
+    echo "Migrating existing config to 3-mode system..."
+    python3 -c "
+from superlocalmemory.core.config import SLMConfig
+SLMConfig.migrate_to_3mode()
+print('✓ Config migrated — your settings preserved')
+"
 else
     echo "○ Config exists (keeping existing)"
 fi

package/src/superlocalmemory/__init__.py

@@ -3,7 +3,7 @@
 import os
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 
-__version__ = "3.4.54"
+__version__ = "3.4.55"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/server/unified_daemon.py

@@ -1098,6 +1098,192 @@ def _register_dashboard_routes(application: FastAPI) -> None:
     async def api_version():
         return JSONResponse({"version": _SLM_VERSION})
 
+    # v3.4.55: Mode switching & config API for the dashboard UI.
+    # The auto-settings.js expects /api/v3/* endpoints. These routes
+    # bridge the 3-mode config system to the existing settings page.
+
+    @application.get("/api/v3/auto")
+    async def v3_auto_detect():
+        """Auto-detect available providers from environment."""
+        import os as _os
+        providers = []
+        if _os.environ.get("OPENROUTER_API_KEY"):
+            providers.append({"id": "openrouter", "name": "OpenRouter", "has_key": True})
+        if _os.environ.get("OPENAI_API_KEY"):
+            providers.append({"id": "openai", "name": "OpenAI", "has_key": True})
+        if _os.environ.get("ANTHROPIC_API_KEY"):
+            providers.append({"id": "anthropic", "name": "Anthropic", "has_key": True})
+        # Ollama is always available as a local option if the server is reachable
+        try:
+            import httpx as _hx
+            _r = _hx.get("http://localhost:11434/api/tags", timeout=2.0)
+            ollama_models = []
+            if _r.status_code == 200:
+                ollama_models = [m["name"] for m in _r.json().get("models", [])]
+            providers.append({
+                "id": "ollama", "name": "Ollama (local)",
+                "has_key": False, "running": True,
+                "models": ollama_models,
+            })
+        except Exception:
+            providers.append({
+                "id": "ollama", "name": "Ollama (local)",
+                "has_key": False, "running": False, "models": [],
+            })
+        return {"providers": providers}
+
+    @application.get("/api/v3/mode")
+    async def v3_get_mode():
+        """Get current mode and available modes."""
+        from superlocalmemory.core.config import SLMConfig
+        from superlocalmemory.storage.models import Mode as _M
+        _base = Path.home() / ".superlocalmemory"
+        current = SLMConfig.read_current_mode(_base)
+        modes = {}
+        for _m in (_M.A, _M.B, _M.C):
+            _name = _m.value.lower()
+            _path = SLMConfig._mode_config_path(_base, _m)
+            _cfg = None
+            if _path.exists():
+                try:
+                    _cfg = SLMConfig.load(_path)
+                except Exception:
+                    pass
+            modes[_name] = {
+                "label": {"a": "Zero-Cloud", "b": "Local AI", "c": "Cloud Power"}[_name],
+                "config_exists": _path.exists(),
+                "embedding_provider": getattr(_cfg.embedding, "provider", "") if _cfg else "",
+                "embedding_model": getattr(_cfg.embedding, "model_name", "") if _cfg else "",
+                "llm_provider": getattr(_cfg.llm, "provider", "") if _cfg else "",
+                "llm_model": getattr(_cfg.llm, "model", "") if _cfg else "",
+                "reranker": _cfg.retrieval.use_cross_encoder if _cfg else True,
+            }
+        return {"current_mode": current, "modes": modes}
+
+    @application.post("/api/v3/mode/set")
+    async def v3_set_mode(request: Request):
+        """Switch mode and optionally update provider/model. Body matches
+        the auto-settings.js saveSettings() payload."""
+        from superlocalmemory.core.config import SLMConfig
+        try:
+            body = await request.json()
+            new_mode = (body.get("mode") or body.get("settings_mode") or "").lower().strip()
+            if new_mode not in ("a", "b", "c"):
+                return JSONResponse(
+                    {"ok": False, "error": "mode must be a, b, or c"},
+                    status_code=400,
+                )
+            config = SLMConfig.switch_mode(new_mode)
+
+            # If provider/model were sent, update the saved config
+            provider = body.get("provider", "").strip()
+            if provider and new_mode != "a":
+                _base = Path.home() / ".superlocalmemory"
+                from superlocalmemory.core.config import LLMConfig, EmbeddingConfig
+                # Update LLM
+                model = body.get("model", "").strip()
+                api_key = body.get("api_key", "").strip()
+                endpoint = body.get("endpoint", "").strip()
+                if provider or model:
+                    config.llm = LLMConfig(
+                        provider=provider or config.llm.provider,
+                        model=model or config.llm.model,
+                        api_key=api_key or config.llm.api_key,
+                        api_base=endpoint or config.llm.api_base,
+                    )
+                # Update embedding
+                emb_provider = body.get("embedding_provider", "").strip()
+                emb_model = body.get("embedding_model", "").strip()
+                emb_key = body.get("embedding_key", "").strip()
+                if emb_provider or emb_model:
+                    config.embedding = EmbeddingConfig(
+                        provider=emb_provider or config.embedding.provider,
+                        model_name=emb_model or config.embedding.model_name,
+                        dimension=config.embedding.dimension,
+                        api_key=emb_key or config.embedding.api_key,
+                    )
+                config.save(mode_change=True)
+
+            return {
+                "ok": True, "mode": new_mode,
+                "embedding": f"{config.embedding.provider}/{config.embedding.model_name}",
+                "llm": f"{config.llm.provider}/{config.llm.model}",
+                "message": f"Switched to Mode {new_mode.upper()}. Run slm restart to apply.",
+            }
+        except Exception as exc:
+            return JSONResponse({"ok": False, "error": str(exc)}, status_code=500)
+
+    @application.get("/api/v3/ollama/status")
+    async def v3_ollama_status():
+        """Check if Ollama is running and list available models."""
+        try:
+            import httpx as _hx
+            _r = _hx.get("http://localhost:11434/api/tags", timeout=3.0)
+            if _r.status_code == 200:
+                _data = _r.json()
+                return {
+                    "running": True,
+                    "models": [{"name": m["name"], "size": m.get("size", 0)}
+                               for m in _data.get("models", [])],
+                }
+        except Exception:
+            pass
+        return {"running": False, "models": []}
+
+    @application.post("/api/v3/provider/test")
+    async def v3_provider_test(request: Request):
+        """Test a provider connection. Body: {provider, api_key, endpoint}."""
+        try:
+            body = await request.json()
+            provider = body.get("provider", "")
+            api_key = body.get("api_key", "")
+            endpoint = body.get("endpoint", "")
+            if provider == "ollama":
+                import httpx as _hx
+                _r = _hx.get(f"{endpoint or 'http://localhost:11434'}/api/tags", timeout=3.0)
+                return {"ok": _r.status_code == 200, "message": "Ollama reachable" if _r.status_code == 200 else f"HTTP {_r.status_code}"}
+            if provider in ("openai", "openrouter"):
+                import httpx as _hx
+                _url = f"{endpoint or 'https://api.openai.com/v1'}/models"
+                _headers = {"Authorization": f"Bearer {api_key}"}
+                _r = _hx.get(_url, headers=_headers, timeout=5.0)
+                return {"ok": _r.status_code == 200, "message": "API key valid" if _r.status_code == 200 else f"HTTP {_r.status_code}: {_r.text[:200]}"}
+            return {"ok": False, "message": f"Unknown provider: {provider}"}
+        except Exception as exc:
+            return {"ok": False, "message": str(exc)}
+
+    @application.get("/api/v3/embedding/config")
+    async def v3_get_embedding_config():
+        """Get current embedding configuration."""
+        engine = getattr(application.state, "engine", None)
+        if engine is None:
+            return JSONResponse({"ok": False, "error": "engine not initialized"}, status_code=503)
+        config = getattr(engine, "_config", None)
+        if config is None:
+            return JSONResponse({"ok": False, "error": "no config loaded"}, status_code=503)
+        return {
+            "provider": getattr(config.embedding, "provider", ""),
+            "model_name": getattr(config.embedding, "model_name", ""),
+            "dimension": getattr(config.embedding, "dimension", 0),
+        }
+
+    @application.post("/api/v3/embedding/test")
+    async def v3_embedding_test(request: Request):
+        """Test embedding with current config. Body: {text: \"test\"}."""
+        try:
+            body = await request.json()
+            text = body.get("text", "test embedding")
+            engine = getattr(application.state, "engine", None)
+            if engine is None:
+                return {"ok": False, "error": "engine not initialized"}
+            embedder = getattr(engine, "_embedder", None)
+            if embedder is None:
+                return {"ok": False, "error": "embedder not available"}
+            vec = embedder.embed(text)
+            return {"ok": True, "dimensions": len(vec) if vec else 0}
+        except Exception as exc:
+            return {"ok": False, "error": str(exc)}
+
     @application.get("/", response_class=HTMLResponse)
     async def root():
         index_path = UI_DIR / "index.html"

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.54
+Version: 3.4.55
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later