graph-mind-memory 0.3.4__tar.gz → 0.5.0__tar.gz

{graph_mind_memory-0.3.4/graph_mind_memory.egg-info → graph_mind_memory-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.3.4
+Version: 0.5.0
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -13,13 +13,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: torch<3,>=2.2
 Requires-Dist: mcp<3,>=2
 Requires-Dist: numpy
-Requires-Dist: transformers
-Requires-Dist: tiktoken
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: tokenizers>=0.15
+Requires-Dist: huggingface_hub>=0.20
 Requires-Dist: pgserver; python_version < "3.13"
 Requires-Dist: psycopg[binary]
+Requires-Dist: cryptography
 Requires-Dist: psutil
 Requires-Dist: fasteners
 Dynamic: license-file
@@ -48,8 +49,9 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 </div>
 
 > [!NOTE]
-> **Alpha.** Used daily on Windows 11, and checked in a fresh-install, two-PC end-to-end run.
-> The test suite also passes on Linux and macOS in CI, but nobody has used it day to day there yet.
+> **Alpha.** Windows: used daily, with full end-to-end checks (fresh install, two PCs, real
+> Claude and Codex). macOS and Linux: tests and a clean install from PyPI pass in CI on every
+> release and every day, but nobody has used them day to day yet; consider them experimental.
 
 ---
 
@@ -125,8 +127,8 @@ graph-mind-install
 
 If `graph-mind-install` is "not recognized", pip put it in a Scripts folder that is not on your
 PATH (common with the Windows Python install manager). `python -m install` runs the same thing.
-If it stops with `WinError 1114` loading `c10.dll`, Windows is missing the Microsoft Visual C++
-runtime that PyTorch needs: install [vc_redist.x64.exe](https://aka.ms/vs/17/release/vc_redist.x64.exe),
+If it stops with a DLL load error, Windows is missing the Microsoft Visual C++ runtime that the
+embedding runtime needs: install [vc_redist.x64.exe](https://aka.ms/vs/17/release/vc_redist.x64.exe),
 restart, and run the installer again.
 
 or from source:
@@ -139,12 +141,13 @@ python install.py
 
 The installer:
 
-- installs the packages (PyTorch CPU is the large one, about 2 GB);
+- installs the packages (no PyTorch: the embedding model runs on ONNX Runtime);
 - registers the MCP server with every app it finds: Claude Code, Claude Desktop (including the
-  Microsoft Store build) and Codex;
+  Microsoft Store build), Codex, Cursor, Windsurf, Gemini CLI, VS Code (Copilot), Cline and
+  LM Studio;
 - starts the capture service at login (Windows Startup folder, a macOS LaunchAgent, or an XDG
   autostart entry on Linux);
-- downloads the embedding model.
+- downloads the embedding model (about 470 MB, once).
 
 Then restart your AI apps. The server is also listed in the
 [MCP Registry](https://registry.modelcontextprotocol.io) as `io.github.goyohan0611-png/graph-mind`. Running the installer again is safe. Run it again if you move the folder.
@@ -168,6 +171,7 @@ stops the capture service. Your memory stays in `~/.graph-mind` unless you add `
 | Claude Code: terminal, VS Code, Claude desktop's Code tab | every turn |
 | Claude desktop: Cowork | every turn |
 | Claude desktop: chat | what the model saves with `brain_remember` |
+| Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio | what the model saves with `brain_remember` (memory tools connected; their transcripts are not read yet) |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
@@ -231,8 +235,10 @@ PCs reach it over the local network in the office, or over [Tailscale](https://t
 anywhere. Each connection tries the addresses in turn and uses the first that answers.
 
 Other PCs log in with a generated password, as a role that can reach only the memory database. The
-Windows firewall rule admits only the local network and Tailscale. The code contains the password:
-do not post it publicly.
+Windows firewall rule admits only the local network and Tailscale. Every line of memory is
+encrypted (AES with an HMAC) under a key derived from that password before it leaves a PC, so the
+network and the hub's own database carry only ciphertext. The code contains the password: do not
+post it publicly.
 
 A synced folder also works. Tell the AI *"use my Google Drive's Graph-MIND folder as my memory"* on
 each PC.
@@ -258,9 +264,9 @@ python -m unittest discover -p "test_*.py"
 
 ## Known limits
 
-- **For about the first half minute after an AI app starts, answers use word search only** while the
-  embedding model loads in the background (the first answer takes ~2.5 s instead of waiting out a
-  30-50 s load on a slow or synced disk). After that, questions take well under a second.
+- **For the first few seconds after an AI app starts, answers use word search only** while the
+  embedding model loads in the background (6-9 s on a slow, synced disk; it was 50-70 s before
+  0.4). The first answer never waits for it; later answers take well under a second.
 - **Daily use on Windows only so far.** macOS and Linux pass the tests in CI but have not seen real
   use.
 - **Capture follows each app's transcript format,** which is not a public interface. An app update

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/README.md

@@ -22,8 +22,9 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 </div>
 
 > [!NOTE]
-> **Alpha.** Used daily on Windows 11, and checked in a fresh-install, two-PC end-to-end run.
-> The test suite also passes on Linux and macOS in CI, but nobody has used it day to day there yet.
+> **Alpha.** Windows: used daily, with full end-to-end checks (fresh install, two PCs, real
+> Claude and Codex). macOS and Linux: tests and a clean install from PyPI pass in CI on every
+> release and every day, but nobody has used them day to day yet; consider them experimental.
 
 ---
 
@@ -99,8 +100,8 @@ graph-mind-install
 
 If `graph-mind-install` is "not recognized", pip put it in a Scripts folder that is not on your
 PATH (common with the Windows Python install manager). `python -m install` runs the same thing.
-If it stops with `WinError 1114` loading `c10.dll`, Windows is missing the Microsoft Visual C++
-runtime that PyTorch needs: install [vc_redist.x64.exe](https://aka.ms/vs/17/release/vc_redist.x64.exe),
+If it stops with a DLL load error, Windows is missing the Microsoft Visual C++ runtime that the
+embedding runtime needs: install [vc_redist.x64.exe](https://aka.ms/vs/17/release/vc_redist.x64.exe),
 restart, and run the installer again.
 
 or from source:
@@ -113,12 +114,13 @@ python install.py
 
 The installer:
 
-- installs the packages (PyTorch CPU is the large one, about 2 GB);
+- installs the packages (no PyTorch: the embedding model runs on ONNX Runtime);
 - registers the MCP server with every app it finds: Claude Code, Claude Desktop (including the
-  Microsoft Store build) and Codex;
+  Microsoft Store build), Codex, Cursor, Windsurf, Gemini CLI, VS Code (Copilot), Cline and
+  LM Studio;
 - starts the capture service at login (Windows Startup folder, a macOS LaunchAgent, or an XDG
   autostart entry on Linux);
-- downloads the embedding model.
+- downloads the embedding model (about 470 MB, once).
 
 Then restart your AI apps. The server is also listed in the
 [MCP Registry](https://registry.modelcontextprotocol.io) as `io.github.goyohan0611-png/graph-mind`. Running the installer again is safe. Run it again if you move the folder.
@@ -142,6 +144,7 @@ stops the capture service. Your memory stays in `~/.graph-mind` unless you add `
 | Claude Code: terminal, VS Code, Claude desktop's Code tab | every turn |
 | Claude desktop: Cowork | every turn |
 | Claude desktop: chat | what the model saves with `brain_remember` |
+| Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio | what the model saves with `brain_remember` (memory tools connected; their transcripts are not read yet) |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
@@ -205,8 +208,10 @@ PCs reach it over the local network in the office, or over [Tailscale](https://t
 anywhere. Each connection tries the addresses in turn and uses the first that answers.
 
 Other PCs log in with a generated password, as a role that can reach only the memory database. The
-Windows firewall rule admits only the local network and Tailscale. The code contains the password:
-do not post it publicly.
+Windows firewall rule admits only the local network and Tailscale. Every line of memory is
+encrypted (AES with an HMAC) under a key derived from that password before it leaves a PC, so the
+network and the hub's own database carry only ciphertext. The code contains the password: do not
+post it publicly.
 
 A synced folder also works. Tell the AI *"use my Google Drive's Graph-MIND folder as my memory"* on
 each PC.
@@ -232,9 +237,9 @@ python -m unittest discover -p "test_*.py"
 
 ## Known limits
 
-- **For about the first half minute after an AI app starts, answers use word search only** while the
-  embedding model loads in the background (the first answer takes ~2.5 s instead of waiting out a
-  30-50 s load on a slow or synced disk). After that, questions take well under a second.
+- **For the first few seconds after an AI app starts, answers use word search only** while the
+  embedding model loads in the background (6-9 s on a slow, synced disk; it was 50-70 s before
+  0.4). The first answer never waits for it; later answers take well under a second.
 - **Daily use on Windows only so far.** macOS and Linux pass the tests in CI but have not seen real
   use.
 - **Capture follows each app's transcript format,** which is not a public interface. An app update

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/brain_log.py

@@ -145,6 +145,7 @@ def share(open_firewall: bool = True) -> dict:
     local_postgres()                        # first: it explains a missing pgserver
     from pgserver._commands import pg_ctl
     password = _config().get("share_password") or secrets.token_urlsafe(18)
+    _save({"share_password": password})          # before sealing: the line key derives from it
     data = _pg_data()
     with psycopg.connect(_admin_uri(), autocommit=True) as admin:
         # token_urlsafe is [A-Za-z0-9_-]: nothing in it can close the quoted literal
@@ -160,11 +161,11 @@ def share(open_firewall: bool = True) -> dict:
     pg_ctl(["-w", "-m", "fast", "restart"] if restart else ["reload"], pgdata=data, timeout=60,
            **_DETACHED)
     set_folder("local")
-    _save({"share_password": password})
+    sealed = _seal_existing(local_postgres())
     hosts = _addresses()
     code = CODE_PREFIX + base64.urlsafe_b64encode(json.dumps(
         {"h": hosts, "p": PORT, "k": password}).encode()).decode().rstrip("=")
-    return {"connection_code": code, "addresses": hosts, "port": PORT,
+    return {"connection_code": code, "addresses": hosts, "port": PORT, "lines_sealed": sealed,
             "firewall": _firewall() if open_firewall else "not changed"}
 
 
@@ -308,7 +309,8 @@ def _shared_ids(shared) -> set:
     """(kind, id) of every turn and memory the shared log holds, forgotten ones included."""
     if is_database(shared):
         with _pg(shared) as connection:
-            lines = [row[0] for row in connection.execute("SELECT line FROM brain_log")]
+            lines = [line for line in (_unseal(shared, row[0]) for row in
+                     connection.execute("SELECT line FROM brain_log")) if line is not None]
     else:
         lines = [line for log in (Path(shared) / "log").glob("*.jsonl")
                  for line in log.read_text(encoding="utf-8", errors="replace").splitlines()]
@@ -390,6 +392,66 @@ def _cursor_db(index: Path) -> sqlite3.Connection:
     return db
 
 
+SEALED = "gme1:"
+_KEYS = {}
+
+
+def _line_key(url):
+    """The key that seals this hub's lines, or None when it has none.
+
+    The Postgres that pgserver ships is built without SSL, so the connection to a hub is not
+    encrypted: on a shared network anyone could read memory off the wire. Each line is sealed
+    instead (Fernet: AES with an HMAC) under a key derived from the password in the connection
+    code, which every PC that joined holds and nobody else does. The hub stores ciphertext too.
+    A joined PC finds the password in its URL; the hub PC in its own config."""
+    import urllib.parse
+    password = urllib.parse.urlsplit(url).password
+    password = urllib.parse.unquote(password) if password else _config().get("share_password")
+    if not password:
+        return None                               # a hub never shared: nothing leaves this PC
+    if password not in _KEYS:
+        from cryptography.fernet import Fernet
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+        raw = HKDF(algorithm=hashes.SHA256(), length=32, salt=b"graph-mind brain_log",
+                   info=b"line key v1").derive(password.encode())
+        _KEYS[password] = Fernet(base64.urlsafe_b64encode(raw))
+    return _KEYS[password]
+
+
+def _seal(url, lines):
+    key = _line_key(url)
+    return [SEALED + key.encrypt(line.encode()).decode() if key else line for line in lines]
+
+
+def _unseal(url, line):
+    """The plain line, or None when it cannot be opened with this hub's key."""
+    if not line.startswith(SEALED):
+        return line                               # written before sealing began
+    key = _line_key(url)
+    if key is None:
+        return None
+    from cryptography.fernet import InvalidToken
+    try:
+        return key.decrypt(line[len(SEALED):].encode()).decode()
+    except InvalidToken:
+        return None
+
+
+def _seal_existing(url) -> int:
+    """Seal the lines the hub held before it was shared, so none crosses the network in clear."""
+    if _line_key(url) is None:
+        return 0
+    with _pg(url) as connection:
+        rows = connection.execute("SELECT seq, line FROM brain_log WHERE line NOT LIKE %s",
+                                  (SEALED + "%",)).fetchall()
+        with connection.cursor() as cursor:
+            cursor.executemany("UPDATE brain_log SET line = %s WHERE seq = %s",
+                               [(_seal(url, [line])[0], seq) for seq, line in rows])
+        connection.commit()
+    return len(rows)
+
+
 def _pg(url):
     import psycopg
     connection = psycopg.connect(url, autocommit=False)
@@ -432,7 +494,7 @@ def _pg_append(url, lines) -> int:
         connection.execute("SELECT pg_advisory_xact_lock(4242)")
         with connection.cursor() as cursor:
             cursor.executemany("INSERT INTO brain_log(device, line) VALUES (%s, %s)",
-                               [(device_name(), line) for line in lines])
+                               [(device_name(), line) for line in _seal(url, lines)])
         connection.commit()
     return len(lines)
 
@@ -459,7 +521,8 @@ def _new_lines(db: sqlite3.Connection, shared) -> list[str]:
             with db:
                 db.execute("INSERT OR REPLACE INTO brain_log_cursor VALUES(?,?)",
                            (source, rows[-1][0]))
-        return [line for _, line in rows]
+        opened = [_unseal(shared, line) for _, line in rows]
+        return [line for line in opened if line is not None]
     lines = []
     for log in sorted((Path(shared) / "log").glob("*.jsonl")):
         row = db.execute("SELECT offset FROM brain_log_cursor WHERE source=?",

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/forget.py

@@ -96,13 +96,17 @@ def scrub_shared(shared, ids: dict) -> int:
     if not keys:
         return 0
     if is_database(shared):
-        with _pg(shared) as connection:
-            removed = 0
-            for key in keys:
-                removed += connection.execute(
-                    "DELETE FROM brain_log WHERE strpos(line, %s) > 0", (key,)).rowcount
+        from brain_log import _unseal
+        with _pg(shared) as connection:          # lines are sealed: open each to find targets
+            doomed = []
+            for seq, line in connection.execute("SELECT seq, line FROM brain_log").fetchall():
+                text = _unseal(shared, line) or ""
+                if any(key in text for key in keys) and '"kind": "forget"' not in text:
+                    doomed.append(seq)
+            if doomed:
+                connection.execute("DELETE FROM brain_log WHERE seq = ANY(%s)", (doomed,))
             connection.commit()
-        return removed
+        return len(doomed)
     removed = 0
     for log in (Path(shared) / "log").glob("*.jsonl"):
         data = log.read_bytes()

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0/graph_mind_memory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.3.4
+Version: 0.5.0
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -13,13 +13,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: torch<3,>=2.2
 Requires-Dist: mcp<3,>=2
 Requires-Dist: numpy
-Requires-Dist: transformers
-Requires-Dist: tiktoken
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: tokenizers>=0.15
+Requires-Dist: huggingface_hub>=0.20
 Requires-Dist: pgserver; python_version < "3.13"
 Requires-Dist: psycopg[binary]
+Requires-Dist: cryptography
 Requires-Dist: psutil
 Requires-Dist: fasteners
 Dynamic: license-file
@@ -48,8 +49,9 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 </div>
 
 > [!NOTE]
-> **Alpha.** Used daily on Windows 11, and checked in a fresh-install, two-PC end-to-end run.
-> The test suite also passes on Linux and macOS in CI, but nobody has used it day to day there yet.
+> **Alpha.** Windows: used daily, with full end-to-end checks (fresh install, two PCs, real
+> Claude and Codex). macOS and Linux: tests and a clean install from PyPI pass in CI on every
+> release and every day, but nobody has used them day to day yet; consider them experimental.
 
 ---
 
@@ -125,8 +127,8 @@ graph-mind-install
 
 If `graph-mind-install` is "not recognized", pip put it in a Scripts folder that is not on your
 PATH (common with the Windows Python install manager). `python -m install` runs the same thing.
-If it stops with `WinError 1114` loading `c10.dll`, Windows is missing the Microsoft Visual C++
-runtime that PyTorch needs: install [vc_redist.x64.exe](https://aka.ms/vs/17/release/vc_redist.x64.exe),
+If it stops with a DLL load error, Windows is missing the Microsoft Visual C++ runtime that the
+embedding runtime needs: install [vc_redist.x64.exe](https://aka.ms/vs/17/release/vc_redist.x64.exe),
 restart, and run the installer again.
 
 or from source:
@@ -139,12 +141,13 @@ python install.py
 
 The installer:
 
-- installs the packages (PyTorch CPU is the large one, about 2 GB);
+- installs the packages (no PyTorch: the embedding model runs on ONNX Runtime);
 - registers the MCP server with every app it finds: Claude Code, Claude Desktop (including the
-  Microsoft Store build) and Codex;
+  Microsoft Store build), Codex, Cursor, Windsurf, Gemini CLI, VS Code (Copilot), Cline and
+  LM Studio;
 - starts the capture service at login (Windows Startup folder, a macOS LaunchAgent, or an XDG
   autostart entry on Linux);
-- downloads the embedding model.
+- downloads the embedding model (about 470 MB, once).
 
 Then restart your AI apps. The server is also listed in the
 [MCP Registry](https://registry.modelcontextprotocol.io) as `io.github.goyohan0611-png/graph-mind`. Running the installer again is safe. Run it again if you move the folder.
@@ -168,6 +171,7 @@ stops the capture service. Your memory stays in `~/.graph-mind` unless you add `
 | Claude Code: terminal, VS Code, Claude desktop's Code tab | every turn |
 | Claude desktop: Cowork | every turn |
 | Claude desktop: chat | what the model saves with `brain_remember` |
+| Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio | what the model saves with `brain_remember` (memory tools connected; their transcripts are not read yet) |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
@@ -231,8 +235,10 @@ PCs reach it over the local network in the office, or over [Tailscale](https://t
 anywhere. Each connection tries the addresses in turn and uses the first that answers.
 
 Other PCs log in with a generated password, as a role that can reach only the memory database. The
-Windows firewall rule admits only the local network and Tailscale. The code contains the password:
-do not post it publicly.
+Windows firewall rule admits only the local network and Tailscale. Every line of memory is
+encrypted (AES with an HMAC) under a key derived from that password before it leaves a PC, so the
+network and the hub's own database carry only ciphertext. The code contains the password: do not
+post it publicly.
 
 A synced folder also works. Tell the AI *"use my Google Drive's Graph-MIND folder as my memory"* on
 each PC.
@@ -258,9 +264,9 @@ python -m unittest discover -p "test_*.py"
 
 ## Known limits
 
-- **For about the first half minute after an AI app starts, answers use word search only** while the
-  embedding model loads in the background (the first answer takes ~2.5 s instead of waiting out a
-  30-50 s load on a slow or synced disk). After that, questions take well under a second.
+- **For the first few seconds after an AI app starts, answers use word search only** while the
+  embedding model loads in the background (6-9 s on a slow, synced disk; it was 50-70 s before
+  0.4). The first answer never waits for it; later answers take well under a second.
 - **Daily use on Windows only so far.** macOS and Linux pass the tests in CI but have not seen real
   use.
 - **Capture follows each app's transcript format,** which is not a public interface. An app update

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/graph_mind_memory.egg-info/requires.txt

@@ -1,9 +1,10 @@
-torch<3,>=2.2
 mcp<3,>=2
 numpy
-transformers
-tiktoken
+onnxruntime>=1.17
+tokenizers>=0.15
+huggingface_hub>=0.20
 psycopg[binary]
+cryptography
 psutil
 fasteners
 

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/install.py

@@ -3,8 +3,8 @@
     python install.py                      # this PC keeps its own brain
     python install.py --join gm1.XXXX      # ...and joins the brain another PC shared
 
-It installs the Python packages, registers the memory server with Claude Code, Claude Desktop and
-Codex (whichever are installed), starts the capture service at login, and downloads the local
+It installs the Python packages, registers the memory server with every MCP client it finds
+(Claude Code, Claude Desktop, Codex, Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio), starts the capture service at login, and downloads the local
 embedding model so the first question is not the one that waits for it. Running it again is
 safe, and after moving this folder it re-points everything at the new place.
 """
@@ -42,9 +42,9 @@ def packages():
                  "  or install Python or this folder under a shorter path, e.g. C:\\graph-mind")
 
 
-def _json_entry(path: Path, **extra) -> None:
+def _json_entry(path: Path, key: str = "mcpServers", **extra) -> None:
     settings = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
-    servers = settings.setdefault("mcpServers", {})
+    servers = settings.setdefault(key, {})
     environment = {**servers.get(NAME, {}).get("env", {}), **ENV}   # keep the user's own settings
     servers[NAME] = {**extra, "command": sys.executable, "args": [str(SERVER)], "env": environment}
     temporary = path.with_suffix(".graph-mind.tmp")
@@ -85,6 +85,46 @@ def claude_desktop(home: Path) -> list[str]:
     return done[:1]
 
 
+def _vscode_user_dir(home: Path) -> Path:
+    if platform.system() == "Windows":
+        return Path(os.environ.get("APPDATA", home / "AppData" / "Roaming")) / "Code" / "User"
+    if platform.system() == "Darwin":
+        return home / "Library" / "Application Support" / "Code" / "User"
+    return Path(os.environ.get("XDG_CONFIG_HOME") or home / ".config") / "Code" / "User"
+
+
+def _other_apps(home: Path) -> list:
+    """(name, config file, servers key, extra fields) for MCP clients beyond Claude and Codex.
+    An app counts as installed when its own folder exists; its config file is created if not."""
+    vscode = _vscode_user_dir(home)
+    return [
+        ("Cursor", home / ".cursor", home / ".cursor" / "mcp.json", "mcpServers", {}),
+        ("Windsurf", home / ".codeium" / "windsurf",
+         home / ".codeium" / "windsurf" / "mcp_config.json", "mcpServers", {}),
+        ("Gemini CLI", home / ".gemini", home / ".gemini" / "settings.json", "mcpServers", {}),
+        ("LM Studio", home / ".lmstudio", home / ".lmstudio" / "mcp.json", "mcpServers", {}),
+        ("VS Code", vscode, vscode / "mcp.json", "servers", {"type": "stdio"}),
+        ("Cline", vscode / "globalStorage" / "saoudrizwan.claude-dev",
+         vscode / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
+         "mcpServers", {}),
+    ]
+
+
+def other_apps(home: Path) -> list[str]:
+    done = []
+    for name, folder, config, key, extra in _other_apps(home):
+        if not folder.is_dir():
+            continue
+        try:
+            config.parent.mkdir(parents=True, exist_ok=True)
+            _json_entry(config, key, **extra)
+            done.append(name)
+        except ValueError:
+            # a settings file with comments (VS Code allows them) is not JSON: leave it alone
+            step(f"{name}: could not edit {config}; add the server there by hand")
+    return done
+
+
 def _without_codex_block(text: str) -> str:
     """The Codex config without Graph-MIND's server table (and its env table); the rest kept."""
     header = f"[mcp_servers.{NAME}]"
@@ -180,35 +220,32 @@ def capture_service(start: bool) -> str:
 
 def embedding_model():
     sys.path.insert(0, str(HERE))
-    from local_embedder import LOCAL_MODEL, own_hf_home
+    from local_embedder import LOCAL_MODEL, MODEL_FILES, model_paths, own_hf_home
     try:
-        from transformers import AutoModel, AutoTokenizer
-    except OSError as error:
-        if "1114" not in str(error):
+        import onnxruntime  # noqa: F401  (a DLL failure here would leave search on words only)
+    except ImportError as error:
+        if platform.system() != "Windows":
             raise
-        # WinError 1114 on c10.dll: PyTorch needs the Microsoft Visual C++ runtime, which a fresh
-        # Windows often lacks. Everything else is installed; recall uses word search until then.
-        sys.exit(f"\n{error}\n\nPyTorch could not load. Install the Microsoft Visual C++ "
-                 "Redistributable (x64), restart, and run this again:\n"
+        sys.exit(f"\n{error}\n\nThe embedding runtime could not load. Install the Microsoft "
+                 "Visual C++ Redistributable (x64), restart, and run this again:\n"
                  "    https://aka.ms/vs/17/release/vc_redist.x64.exe\n"
                  "The apps are already connected; until then recall works by word search only.")
-
     try:
-        AutoTokenizer.from_pretrained(LOCAL_MODEL)
-        AutoModel.from_pretrained(LOCAL_MODEL)
+        model_paths()
     except OSError as error:
         # ~/.cache refused (access denied): move Hugging Face's whole home under ~/.graph-mind,
         # where every Graph-MIND process looks from now on (local_embedder.use_own_hf_home)
-        if "PermissionError" not in str(error) and not isinstance(error.__cause__, PermissionError):
+        if "PermissionError" not in str(error) and not isinstance(error.__cause__, PermissionError) \
+                and not isinstance(error, PermissionError):
             raise
         own = own_hf_home()
         own.mkdir(parents=True, exist_ok=True)
         step(f"the usual model folder is not writable; using {own}")
         # huggingface_hub fixed its folders when it was imported: download in a fresh process
         subprocess.run([sys.executable, "-c",
-                        "from transformers import AutoModel, AutoTokenizer; "
-                        f"AutoTokenizer.from_pretrained({LOCAL_MODEL!r}); "
-                        f"AutoModel.from_pretrained({LOCAL_MODEL!r})"],
+                        "from huggingface_hub import hf_hub_download; "
+                        + "; ".join(f"hf_hub_download({LOCAL_MODEL!r}, {name!r})"
+                                    for name in MODEL_FILES)],
                        env={**os.environ, "HF_HOME": str(own),
                             "HF_HUB_DISABLE_SYMLINKS_WARNING": "1"}, check=True)
 
@@ -230,7 +267,8 @@ def main(argv=None):
         step("installing packages (the first time takes a few minutes)")
         packages()
     home = Path.home()
-    apps = [name for name in [claude_code(home), *claude_desktop(home), codex(home)] if name]
+    apps = [name for name in [claude_code(home), *claude_desktop(home), codex(home),
+                              *other_apps(home)] if name]
     step("memory connected to: " + (", ".join(apps) if apps else
                                      "no AI app found yet; install one and run this again"))
     step(capture_service(start=not args.no_start))
@@ -258,17 +296,23 @@ def uninstall(argv=None):
     claude = shutil.which("claude")
     if claude:
         subprocess.run([claude, "mcp", "remove", "-s", "user", NAME], capture_output=True)
-    for config in [home / ".claude.json"] + [r / "claude_desktop_config.json"
-                                              for r in _desktop_roots(home)]:
+    targets = ([("Claude Code", home / ".claude.json", "mcpServers")]
+               + [("Claude Desktop", r / "claude_desktop_config.json", "mcpServers")
+                  for r in _desktop_roots(home)]
+               + [(name, config, key) for name, _, config, key, _ in _other_apps(home)])
+    for label, config, key in targets:
         if not config.exists():
             continue
-        settings = json.loads(config.read_text(encoding="utf-8"))
-        if settings.get("mcpServers", {}).pop(NAME, None) is not None:
+        try:
+            settings = json.loads(config.read_text(encoding="utf-8"))
+        except ValueError:
+            continue
+        if settings.get(key, {}).pop(NAME, None) is not None:
             temporary = config.with_suffix(".graph-mind.tmp")
             temporary.write_text(json.dumps(settings, ensure_ascii=False, indent=2),
                                  encoding="utf-8")
             os.replace(temporary, config)
-            removed.append("Claude Code" if config.name == ".claude.json" else "Claude Desktop")
+            removed.append(label)
     codex_config = home / ".codex" / "config.toml"
     if codex_config.exists():
         text = codex_config.read_text(encoding="utf-8")

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/local_embedder.py

@@ -36,17 +36,34 @@ def use_own_hf_home() -> None:
 use_own_hf_home()
 
 
+MODEL_FILES = ("tokenizer.json", "onnx/model.onnx")
+
+
 def model_on_disk() -> bool:
+    """Both files the embedder reads are already downloaded (an install from before 0.4 has the
+    torch weights in the same folder, but not the ONNX file)."""
     hf_home = Path(os.environ.get("HF_HOME") or Path.home() / ".cache" / "huggingface")
-    return (hf_home / "hub" / ("models--" + LOCAL_MODEL.replace("/", "--"))).is_dir()
+    snapshots = hf_home / "hub" / ("models--" + LOCAL_MODEL.replace("/", "--")) / "snapshots"
+    return any(all((snapshot / name).exists() for name in MODEL_FILES)
+               for snapshot in (snapshots.iterdir() if snapshots.is_dir() else []))
+
+
+def model_paths(model=LOCAL_MODEL) -> tuple:
+    """Local paths of the tokenizer and the ONNX model, downloaded on first use."""
+    from huggingface_hub import hf_hub_download
+    return tuple(hf_hub_download(model, name) for name in MODEL_FILES)
 
 
 class LocalEmbedder:
-    """On-device multilingual embeddings via raw transformers (mean pooling, L2-normalized).
-    No text leaves the machine — required by the user-owned local-brain promise."""
+    """On-device multilingual embeddings: the model's own ONNX export run by ONNX Runtime,
+    mean pooling, L2-normalized. No text leaves the machine.
+
+    Until 0.4 this ran on torch + transformers: same model, same vectors (on 1,000 texts the
+    largest difference was 2.4e-7, cosine 1.000000), but a 2 GB install, the Visual C++ runtime,
+    and 48-71 s to load on a OneDrive-synced Windows PC against 6-9 s now."""
 
-    _model = None
-    _tok = None
+    _model = None            # an onnxruntime.InferenceSession
+    _tok = None              # a tokenizers.Tokenizer
     _lock = threading.RLock()  # model load + cache writes are not thread-safe
 
     FLUSH_EVERY = 5000   # vectors between writes: bounds lost work without rewriting per call
@@ -69,11 +86,17 @@ class LocalEmbedder:
 
     def _load(self):
         if LocalEmbedder._model is None:
-            import torch
-            from transformers import AutoModel, AutoTokenizer
-            LocalEmbedder._tok = AutoTokenizer.from_pretrained(self.model_name)
-            LocalEmbedder._model = AutoModel.from_pretrained(self.model_name).eval()
-            LocalEmbedder._torch = torch
+            import onnxruntime
+            from tokenizers import Tokenizer
+            tokenizer_file, model_file = model_paths(self.model_name)
+            tokenizer = Tokenizer.from_file(tokenizer_file)
+            tokenizer.enable_truncation(256)          # as transformers did: max_length=256
+            tokenizer.enable_padding()
+            options = onnxruntime.SessionOptions()
+            options.log_severity_level = 3            # warnings about unused initializers: noise
+            LocalEmbedder._tok = tokenizer
+            LocalEmbedder._model = onnxruntime.InferenceSession(
+                model_file, options, providers=["CPUExecutionProvider"])
             LocalEmbedder._loaded.set()
 
     def ready(self, timeout) -> bool:
@@ -97,16 +120,18 @@ class LocalEmbedder:
         return hashlib.sha256((self.model_name + "\0" + text).encode("utf-8")).hexdigest()
 
     def _encode(self, texts):
-        import torch
-        torch = LocalEmbedder._torch
-        batch = LocalEmbedder._tok(texts, padding=True, truncation=True,
-                                   max_length=256, return_tensors="pt")
-        with torch.no_grad():
-            out = LocalEmbedder._model(**batch)
-        mask = batch["attention_mask"].unsqueeze(-1).float()
-        emb = (out.last_hidden_state * mask).sum(1) / mask.sum(1).clamp(min=1e-9)
-        emb = torch.nn.functional.normalize(emb, dim=1)
-        return emb.tolist()
+        import numpy as np
+        encoded = LocalEmbedder._tok.encode_batch(texts)
+        ids = np.array([e.ids for e in encoded], dtype=np.int64)
+        mask = np.array([e.attention_mask for e in encoded], dtype=np.int64)
+        feed = {"input_ids": ids, "attention_mask": mask}
+        if "token_type_ids" in {i.name for i in LocalEmbedder._model.get_inputs()}:
+            feed["token_type_ids"] = np.zeros_like(ids)
+        hidden = LocalEmbedder._model.run(None, feed)[0]
+        weights = mask[..., None].astype(np.float32)
+        pooled = (hidden * weights).sum(1) / np.clip(weights.sum(1), 1e-9, None)
+        pooled /= np.clip(np.linalg.norm(pooled, axis=1, keepdims=True), 1e-12, None)
+        return pooled.tolist()
 
     def embed(self, texts):
         texts = [t.strip()[:2000] for t in texts]

{graph_mind_memory-0.3.4 → graph_mind_memory-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.3.4"
+version = "0.5.0"
 description = "Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,15 +18,16 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "torch>=2.2,<3",
     "mcp>=2,<3",
     "numpy",
-    "transformers",
-    "tiktoken",
+    "onnxruntime>=1.17",
+    "tokenizers>=0.15",
+    "huggingface_hub>=0.20",
     # hosts the shared brain's Postgres; built for Python 3.9-3.12 only. Joining another PC's
     # brain (psycopg) and everything else work on any supported Python.
     "pgserver; python_version < '3.13'",
     "psycopg[binary]",
+    "cryptography",          # seals lines on a shared hub
     "psutil",
     "fasteners",
 ]