feat: 登录页增加记住密码 checkbox + ONNX INT8 量化 + bump v1.0.18

Author: macos

aivectormemory/db/memory_repo.py

@@ -30,10 +30,11 @@ def _match_filters(self, mem, filters) -> bool:
         source = filters.get("source")
         return not source or mem.get("source", "manual") == source
 
-    def list_by_tags(self, tags: list[str], scope: str = "all", project_dir: str = "",
-                     limit: int = 100, source: str | None = None,
-                     tags_mode: str = "all", **_) -> list[dict]:
-        sql, params = "SELECT * FROM memories WHERE 1=1", []
+    def _build_tag_filter(self, base_sql: str, tags: list[str],
+                          tags_mode: str, scope: str = "all",
+                          project_dir: str = "", source: str | None = None,
+                          query: str | None = None) -> tuple[str, list]:
+        sql, params = base_sql, []
         if scope == "project":
             sql += " AND project_dir=?"
             params.append(project_dir or self.project_dir)
@@ -48,25 +49,62 @@ def list_by_tags(self, tags: list[str], scope: str = "all", project_dir: str = "
             for tag in tags:
                 sql += " AND id IN (SELECT memory_id FROM memory_tags WHERE tag=?)"
                 params.append(tag)
-        sql += " ORDER BY created_at DESC LIMIT ?"
-        params.append(limit)
+        if query:
+            sql += " AND content LIKE ?"
+            params.append(f"%{query}%")
+        return sql, params
+
+    def list_by_tags(self, tags: list[str], scope: str = "all", project_dir: str = "",
+                     limit: int = 100, offset: int = 0, source: str | None = None,
+                     tags_mode: str = "all", query: str | None = None, **_) -> list[dict]:
+        sql, params = self._build_tag_filter(
+            "SELECT * FROM memories WHERE 1=1",
+            tags, tags_mode, scope, project_dir, source, query)
+        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
         return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
 
-    def get_all(self, limit: int = 100, offset: int = 0, project_dir: str | None = None) -> list[dict]:
-        if project_dir is not None:
-            rows = self.conn.execute(
-                "SELECT * FROM memories WHERE project_dir = ? ORDER BY created_at DESC LIMIT ? OFFSET ?",
-                (project_dir, limit, offset)).fetchall()
-        else:
-            rows = self.conn.execute(
-                "SELECT * FROM memories ORDER BY created_at DESC LIMIT ? OFFSET ?",
-                (limit, offset)).fetchall()
-        return [dict(r) for r in rows]
+    def count_by_tags(self, tags: list[str], scope: str = "all", project_dir: str = "",
+                      source: str | None = None, tags_mode: str = "all",
+                      query: str | None = None) -> int:
+        sql, params = self._build_tag_filter(
+            "SELECT COUNT(*) FROM memories WHERE 1=1",
+            tags, tags_mode, scope, project_dir, source, query)
+        return self.conn.execute(sql, params).fetchone()[0]
 
-    def count(self, project_dir: str | None = None) -> int:
+    def _build_filter(self, base_sql: str, project_dir: str | None = None,
+                      query: str | None = None, source: str | None = None,
+                      exclude_tags: list[str] | None = None) -> tuple[str, list]:
+        sql, params = base_sql, []
         if project_dir is not None:
-            return self.conn.execute("SELECT COUNT(*) FROM memories WHERE project_dir=?", (project_dir,)).fetchone()[0]
-        return self.conn.execute("SELECT COUNT(*) FROM memories").fetchone()[0]
+            sql += " AND project_dir = ?"
+            params.append(project_dir)
+        if query:
+            sql += " AND content LIKE ?"
+            params.append(f"%{query}%")
+        if source:
+            sql += " AND source = ?"
+            params.append(source)
+        if exclude_tags:
+            for tag in exclude_tags:
+                sql += " AND id NOT IN (SELECT memory_id FROM memory_tags WHERE tag=?)"
+                params.append(tag)
+        return sql, params
+
+    def get_all(self, limit: int = 100, offset: int = 0, project_dir: str | None = None,
+                query: str | None = None, source: str | None = None,
+                exclude_tags: list[str] | None = None) -> list[dict]:
+        sql, params = self._build_filter(
+            "SELECT * FROM memories WHERE 1=1", project_dir, query, source, exclude_tags)
+        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+        return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
+
+    def count(self, project_dir: str | None = None, query: str | None = None,
+             source: str | None = None, exclude_tags: list[str] | None = None) -> int:
+        sql, params = self._build_filter(
+            "SELECT COUNT(*) FROM memories WHERE 1=1", project_dir, query, source, exclude_tags)
+        return self.conn.execute(sql, params).fetchone()[0]
 
     def get_tag_counts(self, project_dir: str | None = None) -> dict[str, int]:
         if project_dir is not None:

aivectormemory/db/user_memory_repo.py

@@ -17,9 +17,10 @@ def _build_insert(self, mid, content, tags, source, session_id, now, extra):
         vals = [mid, content, json.dumps(tags, ensure_ascii=False), source, session_id, now, now]
         return cols, vals
 
-    def list_by_tags(self, tags: list[str], limit: int = 100, source: str | None = None,
-                     tags_mode: str = "all", **_) -> list[dict]:
-        sql, params = "SELECT * FROM user_memories WHERE 1=1", []
+    def _build_tag_filter(self, base_sql: str, tags: list[str],
+                          tags_mode: str, source: str | None = None,
+                          query: str | None = None) -> tuple[str, list]:
+        sql, params = base_sql, []
         if source:
             sql += " AND source=?"
             params.append(source)
@@ -31,18 +32,59 @@ def list_by_tags(self, tags: list[str], limit: int = 100, source: str | None = N
             for tag in tags:
                 sql += " AND id IN (SELECT memory_id FROM user_memory_tags WHERE tag=?)"
                 params.append(tag)
-        sql += " ORDER BY created_at DESC LIMIT ?"
-        params.append(limit)
+        if query:
+            sql += " AND content LIKE ?"
+            params.append(f"%{query}%")
+        return sql, params
+
+    def list_by_tags(self, tags: list[str], limit: int = 100, offset: int = 0,
+                     source: str | None = None, tags_mode: str = "all",
+                     query: str | None = None, **_) -> list[dict]:
+        sql, params = self._build_tag_filter(
+            "SELECT * FROM user_memories WHERE 1=1",
+            tags, tags_mode, source, query)
+        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
         return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
 
-    def get_all(self, limit: int = 100, offset: int = 0) -> list[dict]:
-        rows = self.conn.execute(
-            "SELECT * FROM user_memories ORDER BY created_at DESC LIMIT ? OFFSET ?",
-            (limit, offset)).fetchall()
-        return [dict(r) for r in rows]
+    def count_by_tags(self, tags: list[str], source: str | None = None,
+                      tags_mode: str = "all", query: str | None = None) -> int:
+        sql, params = self._build_tag_filter(
+            "SELECT COUNT(*) FROM user_memories WHERE 1=1",
+            tags, tags_mode, source, query)
+        return self.conn.execute(sql, params).fetchone()[0]
+
+    def get_all(self, limit: int = 100, offset: int = 0, query: str | None = None,
+                source: str | None = None, exclude_tags: list[str] | None = None) -> list[dict]:
+        sql, params = "SELECT * FROM user_memories WHERE 1=1", []
+        if query:
+            sql += " AND content LIKE ?"
+            params.append(f"%{query}%")
+        if source:
+            sql += " AND source=?"
+            params.append(source)
+        if exclude_tags:
+            for tag in exclude_tags:
+                sql += " AND id NOT IN (SELECT memory_id FROM user_memory_tags WHERE tag=?)"
+                params.append(tag)
+        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+        return [dict(r) for r in self.conn.execute(sql, params).fetchall()]
 
-    def count(self) -> int:
-        return self.conn.execute("SELECT COUNT(*) FROM user_memories").fetchone()[0]
+    def count(self, query: str | None = None, source: str | None = None,
+             exclude_tags: list[str] | None = None) -> int:
+        sql, params = "SELECT COUNT(*) FROM user_memories WHERE 1=1", []
+        if query:
+            sql += " AND content LIKE ?"
+            params.append(f"%{query}%")
+        if source:
+            sql += " AND source=?"
+            params.append(source)
+        if exclude_tags:
+            for tag in exclude_tags:
+                sql += " AND id NOT IN (SELECT memory_id FROM user_memory_tags WHERE tag=?)"
+                params.append(tag)
+        return self.conn.execute(sql, params).fetchone()[0]
 
     def get_tag_counts(self) -> dict[str, int]:
         rows = self.conn.execute(

aivectormemory/embedding/engine.py

@@ -3,15 +3,18 @@
 import numpy as np
 from functools import lru_cache
 from pathlib import Path
-from aivectormemory.config import MODEL_NAME, MODEL_DIMENSION
+from aivectormemory.config import MODEL_NAME, MODEL_DIMENSION, DB_DIR
 from aivectormemory.log import log
 
+QUANTIZED_DIR = DB_DIR / "models"
+QUANTIZED_FILENAME = "model_int8.onnx"
+
 
 class EmbeddingEngine:
     def __init__(self):
         self._session = None
         self._tokenizer = None
-        self._encode_cached = lru_cache(maxsize=4096)(self._encode_impl)
+        self._encode_cached = lru_cache(maxsize=1024)(self._encode_impl)
 
     @property
     def ready(self) -> bool:
@@ -30,15 +33,17 @@ def load(self):
             self._tokenizer.enable_padding()
             self._tokenizer.enable_truncation(max_length=512)
 
-            model_path = model_dir / "model.onnx"
-            if not model_path.exists():
-                model_path = model_dir / "onnx" / "model.onnx"
+            fp32_path = model_dir / "model.onnx"
+            if not fp32_path.exists():
+                fp32_path = model_dir / "onnx" / "model.onnx"
+
+            model_path = self._get_quantized_model(fp32_path)
 
             self._session = ort.InferenceSession(
                 str(model_path),
                 providers=["CPUExecutionProvider"]
             )
-            log.info("Embedding model loaded: %s", MODEL_NAME)
+            log.info("Embedding model loaded: %s (quantized=%s)", MODEL_NAME, model_path != fp32_path)
         except Exception as e:
             log.error("Failed to load embedding model: %s", e)
             raise
@@ -53,6 +58,28 @@ def _download_model(self, hf_hub_download) -> Path:
         ))
         return model_dir
 
+    def _get_quantized_model(self, fp32_path: Path) -> Path:
+        quantized_path = QUANTIZED_DIR / QUANTIZED_FILENAME
+        if quantized_path.exists():
+            return quantized_path
+        tmp_path = quantized_path.with_suffix(".tmp")
+        try:
+            from onnxruntime.quantization import quantize_dynamic, QuantType
+            QUANTIZED_DIR.mkdir(parents=True, exist_ok=True)
+            log.info("Quantizing model to INT8 (first time only)...")
+            quantize_dynamic(str(fp32_path), str(tmp_path), weight_type=QuantType.QInt8)
+            tmp_path.rename(quantized_path)
+            log.info("Quantized model saved: %s (%.0fMB -> %.0fMB)",
+                     quantized_path,
+                     fp32_path.stat().st_size / 1024 / 1024,
+                     quantized_path.stat().st_size / 1024 / 1024)
+            return quantized_path
+        except Exception as e:
+            log.warning("INT8 quantization unavailable (%s), using FP32 model", e)
+            if tmp_path.exists():
+                tmp_path.unlink()
+            return fp32_path
+
     def encode(self, text: str) -> list[float]:
         if not self.ready:
             self.load()

aivectormemory/i18n/rules/de.py

@@ -219,9 +219,10 @@
     "---\n\n"
     "## ⚠️ IDENTITY & TONE\n\n"
     "- Role: Sie sind ein Chefingenieur und Senior Data Scientist\n"
-    "- Language: **Immer auf Deutsch antworten**, unabhängig von der Kontextsprache (einschließlich nach compact/context transfer)\n"
-    "- Voice: Professional, Concise, Result-Oriented. Kein \"Ich hoffe, das hilft\"\n"
-    "- Authority: Der Benutzer ist der Lead Architect. Explizite Befehle sofort ausführen (keine Fragen).\n\n"
+    "- Language: **Immer auf Deutsch antworten**, unabhängig davon, in welcher Sprache der Benutzer fragt, unabhängig von der Kontextsprache (einschließlich nach compact/context transfer/Tools die englische Ergebnisse zurückgeben), **Antworten müssen auf Deutsch sein**\n"
+    "- Voice: Professional, Concise, Result-Oriented. Keine Höflichkeitsfloskeln (\"Ich hoffe, das hilft\", \"Ich helfe gerne\", \"Falls Sie Fragen haben\")\n"
+    "- Authority: Der Benutzer ist der Lead Architect. Explizite Anweisungen sofort ausführen, keine Rückfragen zur Bestätigung. Nur tatsächliche Fragen beantworten\n"
+    "- **Verboten**: Benutzernachrichten übersetzen, Wiederholung dessen was der Benutzer bereits gesagt hat, Diskussionen in einer anderen Sprache zusammenfassen\n\n"
     "---\n\n"
     "## ⚠️ Nachrichtentyp-Beurteilung\n\n"
     "Nach Erhalt einer Benutzernachricht die Bedeutung sorgfältig verstehen und dann den Nachrichtentyp bestimmen. Fragen beschränken sich auf Smalltalk, Fortschrittsabfragen, Regeldiskussionen und einfache Bestätigungen erfordern keine Problemdokumentation. Alle anderen Fälle müssen als Probleme aufgezeichnet werden, dann dem Benutzer die Lösung präsentieren und auf Bestätigung warten bevor ausgeführt wird.\n\n"
@@ -247,13 +248,14 @@
     "- **Korrekter Ansatz**: SQL in `.sql`-Datei schreiben und `< data/xxx.sql` verwenden; Python-Verifizierungsskripte als .py-Dateien schreiben und mit `python3 xxx.py` ausführen; `lsof -ti:Port` + ignoreWarning:true für Port-Prüfungen verwenden\n\n"
     "---\n\n"
     "## ⚠️ Selbsttest-Anforderungen\n\n"
-    "**Niemals den Benutzer bitten manuell zu operieren** — selbst machen wenn möglich\n\n"
-    "- Python: `python -m pytest` oder Skripte direkt ausführen zur Verifizierung\n"
-    "- MCP Server: über stdio JSON-RPC-Nachrichten zur Verifizierung senden\n"
-    "- Web Dashboard: mit Playwright verifizieren\n"
+    "**Niemals den Benutzer bitten manuell zu operieren** — selbst machen wenn möglich. Nur \"wartet auf Verifizierung\" sagen nachdem der Selbsttest bestanden ist.\n\n"
+    "- **Reines Backend / Nicht-Frontend-Änderungen**: pytest, API-Anfragen oder Skripte zur Überprüfung der Funktionalität verwenden\n"
+    "- **MCP Server**: über stdio JSON-RPC-Nachrichten zur Verifizierung senden\n"
+    "- **Änderungen an im Frontend sichtbaren Daten** (Datenbankänderungen, Änderungen der API-Rückgabewerte, Frontend-Code-Änderungen): **muss Playwright verwenden um die Frontend-Seitenanzeigeergebnisse zu verifizieren**. Es ist verboten, nur mit SQL-Abfragen, curl oder Python-Skripten zu verifizieren und \"bestanden\" zu behaupten. Wenn der Dienst nicht läuft, muss der Dienst zuerst gestartet werden. Es ist verboten, Playwright mit der Begründung \"Dienst läuft nicht\" zu überspringen\n"
     "- Nur \"wartet auf Verifizierung\" sagen nachdem der Selbsttest bestanden ist\n\n"
     "---\n\n"
     "## ⚠️ Entwicklungsregeln\n\n"
+    "> Nach Abschluss der Entwicklung muss ein Selbsttest durchgeführt werden.\n"
     "> Keine mündlichen Versprechen — alles wird durch bestandene Tests validiert.\n"
     "> Muss rigoros nachdenken vor jeder Dateiänderung.\n"
     "> Bei Fehlern oder Ausnahmen niemals blind testen. Muss die Grundursache analysieren."

aivectormemory/i18n/rules/en.py

@@ -219,9 +219,10 @@
     "---\n\n"
     "## ⚠️ IDENTITY & TONE\n\n"
     "- Role: You are a Chief Engineer and Senior Data Scientist\n"
-    "- Language: **Always reply in English**, regardless of context language (including after compact/context transfer)\n"
-    "- Voice: Professional, Concise, Result-Oriented. No \"I hope this helps\"\n"
-    "- Authority: The user is the Lead Architect. Execute explicit commands immediately (not questions).\n\n"
+    "- Language: **Always reply in English**, regardless of what language the user asks in, regardless of context language (including after compact/context transfer/tools returning non-English results), **replies must be in English**\n"
+    "- Voice: Professional, Concise, Result-Oriented. No pleasantries (\"I hope this helps\", \"I'm happy to help\", \"If you have any questions\")\n"
+    "- Authority: The user is the Lead Architect. Execute explicit commands immediately, do not ask for confirmation. Only answer actual questions\n"
+    "- **Forbidden**: translating user messages, repeating what the user already said, summarizing discussions in a different language\n\n"
     "---\n\n"
     "## ⚠️ Message Type Judgment\n\n"
     "After receiving a user message, carefully understand its meaning then determine the message type. Questions limited to casual chat, progress checks, rule discussions, and simple confirmations do not require issue documentation. All other cases must be recorded as issues, then present the solution to the user and wait for confirmation before executing.\n\n"
@@ -247,13 +248,14 @@
     "- **Correct approach**: write SQL to `.sql` file and use `< data/xxx.sql`; write Python verification scripts as .py files and run with `python3 xxx.py`; use `lsof -ti:port` + ignoreWarning:true for port checks\n\n"
     "---\n\n"
     "## ⚠️ Self-testing Requirements\n\n"
-    "**Never ask the user to manually operate** — do it yourself if possible\n\n"
-    "- Python: `python -m pytest` or run scripts directly to verify\n"
-    "- MCP Server: verify via stdio JSON-RPC messages\n"
-    "- Web Dashboard: verify with Playwright\n"
+    "**Never ask the user to manually operate** — do it yourself if possible. Only say \"waiting for verification\" after self-test passes.\n\n"
+    "- **Pure backend / non-frontend changes**: use pytest, API requests, or scripts to verify functionality\n"
+    "- **MCP Server**: verify via stdio JSON-RPC messages\n"
+    "- **Changes involving frontend-visible data** (database modifications, API return value changes, frontend code changes): **must use Playwright to verify frontend page display results**. Using only SQL queries, curl, or python scripts to verify and claiming \"passed\" is prohibited. If the service is not running, must start the service first before verifying. Skipping Playwright with the excuse \"service not running\" is prohibited\n"
     "- Only say \"waiting for verification\" after self-test passes\n\n"
     "---\n\n"
     "## ⚠️ Development Rules\n\n"
+    "> Development must be followed by self-testing.\n"
     "> No verbal promises — everything is validated by passing tests.\n"
     "> Must think rigorously before any file modification.\n"
     "> When encountering errors or exceptions, never test blindly. Must analyze the root cause."