added RAG, Multiuser, TG bot

backend/app/settings/__init__.py

@@ -0,0 +1 @@
+"""Runtime settings stored in assistant_state."""

backend/app/settings/service.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.config import Settings, get_settings
+from app.db.models import AssistantState
+
+SETTING_KEYS = (
+    "openrouter_model",
+    "memory_extract_model",
+    "openrouter_reasoning_effort",
+    "rag_enabled",
+    "rag_top_k",
+)
+
+
+class SettingsService:
+    def __init__(self, db: Session):
+        self.db = db
+        self._defaults = get_settings()
+
+    def _get_row(self, key: str) -> AssistantState | None:
+        return self.db.get(AssistantState, key)
+
+    def get_raw(self, key: str) -> str | None:
+        row = self._get_row(key)
+        if not row or not (row.value or "").strip():
+            return None
+        return row.value.strip()
+
+    def set_raw(self, key: str, value: str) -> None:
+        row = self._get_row(key)
+        if not row:
+            row = AssistantState(key=key, value=value)
+            self.db.add(row)
+        else:
+            row.value = value
+        row.updated_at = datetime.now(timezone.utc)
+        self.db.commit()
+
+    def _default_for(self, key: str) -> Any:
+        defaults: Settings = self._defaults
+        mapping = {
+            "openrouter_model": defaults.openrouter_model,
+            "memory_extract_model": defaults.memory_extract_model or defaults.openrouter_model,
+            "openrouter_reasoning_effort": defaults.openrouter_reasoning_effort,
+            "rag_enabled": defaults.rag_enabled,
+            "rag_top_k": defaults.rag_top_k,
+        }
+        return mapping[key]
+
+    def get_effective(self, key: str) -> Any:
+        raw = self.get_raw(key)
+        if raw is None:
+            return self._default_for(key)
+        if key == "rag_enabled":
+            return raw.lower() in ("1", "true", "yes", "on")
+        if key == "rag_top_k":
+            try:
+                return max(1, min(50, int(raw)))
+            except ValueError:
+                return self._default_for(key)
+        return raw
+
+    def snapshot(self) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        for key in SETTING_KEYS:
+            data[key] = self.get_effective(key)
+        data["embedding_model"] = self._defaults.embedding_model
+        data["memory_facts_in_context"] = self._defaults.memory_facts_in_context
+        data["qdrant_url"] = self._defaults.qdrant_url
+        return data
+
+    def patch(self, updates: dict[str, Any]) -> dict[str, Any]:
+        for key, value in updates.items():
+            if key not in SETTING_KEYS:
+                continue
+            if value is None:
+                row = self._get_row(key)
+                if row:
+                    self.db.delete(row)
+                    self.db.commit()
+                continue
+            if key == "rag_enabled":
+                stored = "true" if bool(value) else "false"
+            elif key == "rag_top_k":
+                stored = str(int(value))
+            else:
+                stored = str(value).strip()
+            if not stored and key != "rag_enabled":
+                continue
+            self.set_raw(key, stored)
+        return self.snapshot()