superlocalmemory 3.6.22 → 3.7.0

package/src/superlocalmemory/vector/lancedb_backend.py

@@ -79,7 +79,16 @@ class LanceDBVectorBackend:
             return self._db.create_table("embeddings", schema=schema)
 
     def close(self) -> None:
-        """LanceDB is file-based — no explicit close needed."""
+        """Release this backend's native table and connection references."""
+        for resource in (self._table, self._db):
+            close = getattr(resource, "close", None)
+            if callable(close):
+                try:
+                    close()
+                except Exception:
+                    logger.debug("LanceDB resource close failed", exc_info=True)
+        self._table = None
+        self._db = None
 
     # ------------------------------------------------------------------
     # Write Path
@@ -92,16 +101,33 @@ class LanceDBVectorBackend:
         tiers: list[str],
         profile_id: str = "default",
     ) -> int:
-        """Batch insert vectors."""
+        """Idempotently insert or replace vectors by canonical fact ID."""
         if not fact_ids:
             return 0
         data = [
             {"fact_id": fid, "vector": emb, "tier": tier, "profile_id": profile_id}
             for fid, emb, tier in zip(fact_ids, embeddings, tiers)
         ]
-        self._table.add(data)
+        # `add()` permits duplicate fact IDs on retries.  Store/retry paths are
+        # at-least-once by design, so use LanceDB's merge operation to keep the
+        # projection one-row-per-fact and safe to replay after a restart.
+        (
+            self._table.merge_insert("fact_id")
+            .when_matched_update_all()
+            .when_not_matched_insert_all()
+            .execute(data)
+        )
         return len(data)
 
+    @staticmethod
+    def _fact_predicate(fact_id: str) -> str:
+        """Build a Lance SQL literal without allowing predicate injection."""
+        return "fact_id = '" + fact_id.replace("'", "''") + "'"
+
+    def remove_vector(self, fact_id: str) -> None:
+        """Delete one derived vector after its canonical fact is deleted."""
+        self._table.delete(self._fact_predicate(fact_id))
+
     # ------------------------------------------------------------------
     # Read Path
     # ------------------------------------------------------------------
@@ -111,6 +137,7 @@ class LanceDBVectorBackend:
         query_vector: list[float],
         top_k: int = 50,
         tier_filter: list[str] | None = None,
+        profile_id: str = "default",
     ) -> list[tuple[str, float]]:
         """ANN search with optional tier filter.
 
@@ -131,7 +158,10 @@ class LanceDBVectorBackend:
 
             # Build tier filter string for LanceDB SQL-like where clause
             tier_str = ", ".join(f"'{t}'" for t in tier_filter)
-            results = search.where(f"tier IN ({tier_str})").to_list()
+            profile_literal = profile_id.replace("'", "''")
+            results = search.where(
+                f"tier IN ({tier_str}) AND profile_id = '{profile_literal}'"
+            ).to_list()
 
             # Convert distance → similarity (F-08)
             return [(r["fact_id"], 1.0 - r["_distance"]) for r in results]
@@ -143,7 +173,9 @@ class LanceDBVectorBackend:
     # Bulk Import (sqlite-vec → LanceDB)
     # ------------------------------------------------------------------
 
-    def bulk_import_from_sqlite(self, conn: sqlite3.Connection) -> int:
+    def bulk_import_from_sqlite(
+        self, conn: sqlite3.Connection, profile_id: str = "default",
+    ) -> int:
         """Export embeddings from sqlite-vec → LanceDB.
 
         sqlite-vec stores vectors as raw float32 little-endian blobs
@@ -163,11 +195,15 @@ class LanceDBVectorBackend:
 
         # Get tiers
         tier_map: dict[str, str] = {}
+        profile_map: dict[str, str] = {}
         try:
             for row in conn.execute(
-                "SELECT fact_id, COALESCE(lifecycle, 'active') FROM atomic_facts"
+                "SELECT fact_id, COALESCE(lifecycle, 'active'), profile_id "
+                "FROM atomic_facts WHERE profile_id = ?",
+                (profile_id,),
             ):
                 tier_map[row[0]] = row[1]
+                profile_map[row[0]] = row[2] or "default"
         except sqlite3.OperationalError:
             pass
 
@@ -184,7 +220,10 @@ class LanceDBVectorBackend:
         data = []
         for rowid, blob in rows:
             fact_id = row_map.get(rowid)
-            if fact_id is None:
+            # The rowid mapping is global, but a staged Scale Engine is
+            # explicitly profile-scoped.  Do not import a foreign profile by
+            # giving it a default tier/profile below.
+            if fact_id is None or fact_id not in profile_map:
                 continue
             try:
                 vector = self._decode_vector_blob(blob)
@@ -196,11 +235,20 @@ class LanceDBVectorBackend:
                 "fact_id": fact_id,
                 "vector": vector,
                 "tier": tier,
-                "profile_id": "default",
+                "profile_id": profile_map.get(fact_id, profile_id),
             })
 
         if data:
-            self._table.add(data)
+            by_profile: dict[str, list[dict[str, Any]]] = {}
+            for item in data:
+                by_profile.setdefault(item["profile_id"], []).append(item)
+            for record_profile_id, records in by_profile.items():
+                self.add_vectors(
+                    [item["fact_id"] for item in records],
+                    [item["vector"] for item in records],
+                    [item["tier"] for item in records],
+                    record_profile_id,
+                )
 
         logger.info("LanceDB: imported %d vectors from sqlite-vec", len(data))
         return len(data)

package/bin/slm

@@ -1,59 +0,0 @@
-#!/usr/bin/env bash
-# SuperLocalMemory V3 CLI
-# Part of Qualixar | https://superlocalmemory.com
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PKG_ROOT="$(dirname "$SCRIPT_DIR")"
-SRC_DIR="$PKG_ROOT/src"
-
-# Handle --version / -v directly (fast path)
-for arg in "$@"; do
-    if [ "$arg" = "--version" ] || [ "$arg" = "-v" ]; then
-        VER=$(grep '"version"' "$PKG_ROOT/package.json" 2>/dev/null | head -1 | sed 's/.*"\([0-9][0-9.]*\)".*/\1/')
-        echo "superlocalmemory ${VER:-unknown}"
-        exit 0
-    fi
-done
-
-# LLD-06 §6.3 — prefer the PyInstaller-built binary on the hot hook path.
-# If the onedir binary exists and isn't disabled, run it directly; the
-# binary is stdlib-only and ~30ms cold on Windows. Otherwise fall back
-# to the Python CLI below.
-SLM_HOOK_BIN="${SLM_HOOK_BINARY:-$HOME/.superlocalmemory/bin/slm-hook/slm-hook}"
-if [ "${1:-}" = "hook" ] && [ "${2:-}" = "user_prompt_submit" ] \
-   && [ -x "$SLM_HOOK_BIN" ] \
-   && [ "${SLM_HOOK_BINARY_DISABLED:-0}" != "1" ]; then
-    exec "$SLM_HOOK_BIN"
-fi
-
-# Find Python
-PYTHON=""
-for cmd in python3 python; do
-    if command -v "$cmd" &>/dev/null; then
-        PYTHON="$cmd"
-        break
-    fi
-done
-
-if [ -z "$PYTHON" ]; then
-    echo "Error: Python 3 not found. Install Python 3.11+ from python.org"
-    exit 1
-fi
-
-# Set PYTHONPATH so Python finds the npm package's src/ directory
-if [ -n "$PYTHONPATH" ]; then
-    export PYTHONPATH="$SRC_DIR:$PYTHONPATH"
-else
-    export PYTHONPATH="$SRC_DIR"
-fi
-
-# Prevent PyTorch Metal/MPS GPU memory reservation
-export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
-export PYTORCH_MPS_MEM_LIMIT=0
-export PYTORCH_ENABLE_MPS_FALLBACK=1
-export TOKENIZERS_PARALLELISM=false
-export TORCH_DEVICE=cpu
-export CUDA_VISIBLE_DEVICES=""
-
-# Run V3 CLI
-exec "$PYTHON" -m superlocalmemory.cli.main "$@"

package/bin/slm.bat

@@ -1,77 +0,0 @@
-@echo off
-REM SuperLocalMemory V3 - Windows CLI Wrapper
-REM Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-REM Licensed under MIT License
-REM Repository: https://github.com/qualixar/superlocalmemory
-
-setlocal enabledelayedexpansion
-
-REM Resolve the package src/ directory for PYTHONPATH
-set "SLM_PKG_DIR=%~dp0..\src"
-
-REM Handle --version / -v directly (fast path, no Python needed)
-if "%~1"=="--version" goto :show_version
-if "%~1"=="-v" goto :show_version
-
-REM LLD-06 §6.3 — prefer the PyInstaller-built binary on the hot hook path.
-set "SLM_HOOK_BIN=%USERPROFILE%\.superlocalmemory\bin\slm-hook\slm-hook.exe"
-if defined SLM_HOOK_BINARY set "SLM_HOOK_BIN=%SLM_HOOK_BINARY%"
-if "%~1"=="hook" if "%~2"=="user_prompt_submit" (
-    if exist "%SLM_HOOK_BIN%" (
-        if not "%SLM_HOOK_BINARY_DISABLED%"=="1" (
-            "%SLM_HOOK_BIN%"
-            exit /b %ERRORLEVEL%
-        )
-    )
-)
-
-REM Find Python 3
-where python3 >nul 2>&1
-if %ERRORLEVEL% EQU 0 (
-    set PYTHON_CMD=python3
-    goto :run
-)
-where python >nul 2>&1
-if %ERRORLEVEL% EQU 0 (
-    set PYTHON_CMD=python
-    goto :run
-)
-where py >nul 2>&1
-if %ERRORLEVEL% EQU 0 (
-    set PYTHON_CMD=py -3
-    goto :run
-)
-
-echo Error: Python 3.11+ not found.
-echo Install from: https://python.org/downloads/
-exit /b 1
-
-:show_version
-REM Read version from package.json via findstr
-for /f "tokens=2 delims=:," %%a in ('findstr /C:"\"version\"" "%~dp0..\package.json"') do (
-    set "VER=%%~a"
-    set "VER=!VER: =!"
-    echo superlocalmemory !VER!
-    exit /b 0
-)
-echo superlocalmemory unknown
-exit /b 0
-
-:run
-REM Set PYTHONPATH so Python finds the npm package's src/ directory
-if defined PYTHONPATH (
-    set "PYTHONPATH=%SLM_PKG_DIR%;%PYTHONPATH%"
-) else (
-    set "PYTHONPATH=%SLM_PKG_DIR%"
-)
-
-REM Prevent PyTorch Metal/MPS GPU memory reservation
-set "PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0"
-set "PYTORCH_MPS_MEM_LIMIT=0"
-set "PYTORCH_ENABLE_MPS_FALLBACK=1"
-set "TOKENIZERS_PARALLELISM=false"
-set "TORCH_DEVICE=cpu"
-set "CUDA_VISIBLE_DEVICES="
-
-%PYTHON_CMD% -m superlocalmemory.cli.main %*
-exit /b %ERRORLEVEL%

package/bin/slm.cmd

@@ -1,5 +0,0 @@
-@echo off
-REM SuperLocalMemory V3 - Windows CLI (CMD variant)
-REM Delegates to slm.bat which handles PYTHONPATH and --version
-call "%~dp0slm.bat" %*
-exit /b %ERRORLEVEL%

package/ide/integrations/langchain/README.md

@@ -1,106 +0,0 @@
-# langchain-superlocalmemory
-
-LangChain chat message history backed by [SuperLocalMemory V2](https://github.com/qualixar/superlocalmemory) -- 100% local, zero cloud.
-
-Every message stays on your machine in a SQLite database. No API keys, no subscriptions, no telemetry.
-
-## Prerequisites
-
-- Python 3.10+
-- [SuperLocalMemory V2](https://github.com/qualixar/superlocalmemory) installed (`~/.superlocalmemory/` must exist)
-- `langchain-core >= 1.0.0`
-
-## Installation
-
-```bash
-pip install langchain-superlocalmemory
-```
-
-Or install from source:
-
-```bash
-cd integrations/langchain
-pip install -e .
-```
-
-## Quick Start
-
-```python
-from langchain_core.messages import AIMessage, HumanMessage
-from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
-
-# Create a history for a conversation session
-history = SuperLocalMemoryChatMessageHistory(session_id="my-chat-session")
-
-# Add messages
-history.add_messages([
-    HumanMessage(content="What is SuperLocalMemory?"),
-    AIMessage(content="It's a local-first memory system for AI assistants."),
-])
-
-# Retrieve messages (chronological order)
-for msg in history.messages:
-    print(f"{msg.type}: {msg.content}")
-
-# Clear the session
-history.clear()
-```
-
-## Features
-
-- **Local-first storage** -- all data stays in `~/.superlocalmemory/memory.db`
-- **Session isolation** -- each `session_id` is completely independent
-- **Full LangChain compatibility** -- implements `BaseChatMessageHistory`
-- **Persistent across restarts** -- SQLite-backed, survives process exit
-- **Works alongside SLM** -- messages are queryable via CLI, MCP, Skills, and REST API
-- **All message types** -- HumanMessage, AIMessage, SystemMessage, FunctionMessage, ToolMessage
-- **additional_kwargs preserved** -- metadata round-trips through serialization
-
-## Multi-Session Example
-
-```python
-from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
-
-# Two independent conversations
-support = SuperLocalMemoryChatMessageHistory(session_id="support-ticket-42")
-coding = SuperLocalMemoryChatMessageHistory(session_id="code-review-pr-99")
-
-# Messages are isolated -- support session cannot see coding session
-support.add_messages([HumanMessage(content="My app is crashing")])
-coding.add_messages([HumanMessage(content="Review this PR please")])
-
-assert len(support.messages) == 1
-assert len(coding.messages) == 1
-```
-
-## Custom Database Path
-
-By default the package uses `~/.superlocalmemory/memory.db`. You can point to a different database:
-
-```python
-history = SuperLocalMemoryChatMessageHistory(
-    session_id="my-session",
-    db_path="/path/to/custom/memory.db",
-)
-```
-
-## How It Works
-
-Each LangChain message is stored as an individual memory entry in SuperLocalMemory V2:
-
-- **Content**: JSON-serialized message (type, content, additional_kwargs)
-- **Tags**: `["langchain", "langchain:session:<session_id>"]`
-- **Importance**: 3 (lower than user memories, so chat history does not crowd search results)
-- **Project**: `"langchain"`
-
-This means your LangChain conversations are visible in the SLM dashboard, searchable via `slm recall`, and accessible from any SLM-integrated tool.
-
-## License
-
-AGPL-3.0 -- see [LICENSE](../../LICENSE) for details.
-
-## Links
-
-- [SuperLocalMemory V2 Repository](https://github.com/qualixar/superlocalmemory)
-- [Documentation](https://superlocalmemory.com/)
-- [LangChain Documentation](https://python.langchain.com/)

package/ide/integrations/langchain/langchain_superlocalmemory/__init__.py

@@ -1,9 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-or-later
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-from langchain_superlocalmemory.chat_message_history import (
-    SuperLocalMemoryChatMessageHistory,
-)
-
-__all__ = ["SuperLocalMemoryChatMessageHistory"]
-__version__ = "0.1.0"

package/ide/integrations/langchain/langchain_superlocalmemory/chat_message_history.py

@@ -1,201 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-or-later
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""SuperLocalMemory V2 - LangChain Chat Message History
-
-Implements LangChain's BaseChatMessageHistory backed by SuperLocalMemory V2's
-local SQLite storage. All data stays on your machine -- zero cloud, zero telemetry.
-
-Usage:
-    from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
-
-    history = SuperLocalMemoryChatMessageHistory(session_id="my-session")
-    history.add_messages([HumanMessage(content="Hello")])
-    print(history.messages)
-"""
-import json
-import sys
-from pathlib import Path
-from typing import List, Optional, Sequence
-
-from langchain_core.chat_history import BaseChatMessageHistory
-from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
-    FunctionMessage,
-    HumanMessage,
-    SystemMessage,
-    ToolMessage,
-    message_to_dict,
-    messages_from_dict,
-)
-
-# ---------------------------------------------------------------------------
-# MemoryStoreV2 import strategy
-# ---------------------------------------------------------------------------
-# SuperLocalMemory V2 installs to ~/.superlocalmemory/. We add that path so
-# the MemoryStoreV2 class can be imported. If SLM is not installed, we
-# raise a clear error at construction time (not import time) so the package
-# itself can still be imported for introspection.
-# ---------------------------------------------------------------------------
-
-_SLM_PATH = Path.home() / ".superlocalmemory"
-_MemoryStoreV2 = None
-
-
-def _ensure_slm_imported():
-    """Lazily import MemoryStoreV2, raising a clear error if unavailable."""
-    global _MemoryStoreV2
-    if _MemoryStoreV2 is not None:
-        return _MemoryStoreV2
-
-    slm_path_str = str(_SLM_PATH)
-    if slm_path_str not in sys.path:
-        sys.path.insert(0, slm_path_str)
-
-    try:
-        from superlocalmemory.core.engine import MemoryEngine  # type: ignore[import-untyped]
-
-        _MemoryStoreV2 = MemoryStoreV2
-        return _MemoryStoreV2
-    except ImportError as exc:
-        raise ImportError(
-            "SuperLocalMemory V2 is not installed. "
-            "Run the installer from https://github.com/qualixar/superlocalmemory "
-            "or ensure ~/.superlocalmemory/is installed via npm/pip."
-        ) from exc
-
-
-# ---------------------------------------------------------------------------
-# Message (de)serialization helpers
-# ---------------------------------------------------------------------------
-
-# Map from LangChain message type string to the concrete class used for
-# deserialization. LangChain's own `messages_from_dict` handles this, but we
-# keep a lookup for the fallback path in case the dict format diverges.
-
-_MESSAGE_TYPE_MAP = {
-    "human": HumanMessage,
-    "ai": AIMessage,
-    "system": SystemMessage,
-    "function": FunctionMessage,
-    "tool": ToolMessage,
-}
-
-
-def _serialize_message(message: BaseMessage) -> str:
-    """Serialize a LangChain BaseMessage to a JSON string for SLM storage."""
-    return json.dumps(message_to_dict(message), ensure_ascii=False)
-
-
-def _deserialize_messages(dicts: List[dict]) -> List[BaseMessage]:
-    """Deserialize a list of message dicts back to BaseMessage instances.
-
-    Uses LangChain's ``messages_from_dict`` which handles all known message
-    types including ``additional_kwargs``.
-    """
-    return messages_from_dict(dicts)
-
-
-# ---------------------------------------------------------------------------
-# Main class
-# ---------------------------------------------------------------------------
-
-
-class SuperLocalMemoryChatMessageHistory(BaseChatMessageHistory):
-    """LangChain chat message history backed by SuperLocalMemory V2.
-
-    Each message is stored as an individual memory entry in the SLM SQLite
-    database, tagged with the session ID for isolation.  This keeps the data
-    fully local and queryable via any SLM access method (MCP, CLI, Skills,
-    REST API).
-
-    Parameters
-    ----------
-    session_id : str
-        Unique identifier for the conversation session.  Messages from
-        different session IDs are completely isolated.
-    db_path : str or None
-        Path to the SQLite database file.  Defaults to
-        ``~/.superlocalmemory/memory.db``.
-    """
-
-    # Tag prefix used to isolate LangChain session messages inside SLM.
-    _TAG_PREFIX = "langchain:session:"
-
-    def __init__(self, session_id: str, db_path: Optional[str] = None) -> None:
-        self.session_id = session_id
-        self.db_path = db_path
-
-        MemoryStoreV2 = _ensure_slm_imported()
-        store_path = Path(db_path) if db_path else None
-        self._store = MemoryStoreV2(db_path=store_path)
-
-    # -- property: messages ------------------------------------------------
-
-    @property
-    def messages(self) -> List[BaseMessage]:  # type: ignore[override]
-        """Return all messages for this session, ordered chronologically."""
-        session_tag = f"{self._TAG_PREFIX}{self.session_id}"
-
-        # Retrieve a generous batch from SLM.  We filter by tag in Python
-        # because list_all does not accept a tag filter parameter.
-        all_memories = self._store.list_all(limit=10_000)
-
-        # Filter to memories belonging to this session.
-        session_memories = [
-            m for m in all_memories if session_tag in (m.get("tags") or [])
-        ]
-
-        # list_all returns newest-first (ORDER BY created_at DESC).
-        # We need chronological (oldest-first) order for chat history.
-        session_memories.sort(key=lambda m: m.get("created_at", ""))
-
-        # Deserialize each memory's content back to a BaseMessage.
-        message_dicts: List[dict] = []
-        for mem in session_memories:
-            try:
-                parsed = json.loads(mem["content"])
-                message_dicts.append(parsed)
-            except (json.JSONDecodeError, KeyError, TypeError):
-                # Skip malformed entries silently -- they may be non-LangChain
-                # memories that happen to share the tag pattern.
-                continue
-
-        if not message_dicts:
-            return []
-
-        return _deserialize_messages(message_dicts)
-
-    # -- add_messages ------------------------------------------------------
-
-    def add_messages(self, messages: Sequence[BaseMessage]) -> None:
-        """Persist messages to SuperLocalMemory V2.
-
-        Each message becomes a separate memory entry tagged with the session
-        identifier.  Importance is set to 3 (lower than typical user
-        memories at 5) so LangChain history does not crowd out higher-value
-        entries in search results.
-        """
-        session_tag = f"{self._TAG_PREFIX}{self.session_id}"
-
-        for message in messages:
-            serialized = _serialize_message(message)
-            self._store.add_memory(
-                content=serialized,
-                tags=["langchain", session_tag],
-                importance=3,
-                project_name="langchain",
-            )
-
-    # -- clear -------------------------------------------------------------
-
-    def clear(self) -> None:
-        """Remove all messages for this session from the store."""
-        session_tag = f"{self._TAG_PREFIX}{self.session_id}"
-
-        all_memories = self._store.list_all(limit=10_000)
-
-        for mem in all_memories:
-            if session_tag in (mem.get("tags") or []):
-                self._store.delete_memory(mem["id"])

package/ide/integrations/langchain/pyproject.toml

@@ -1,38 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "langchain-superlocalmemory"
-version = "0.1.0"
-description = "LangChain chat message history backed by SuperLocalMemory — 100% local, zero cloud"
-readme = "README.md"
-license = "AGPL-3.0-or-later"
-requires-python = ">=3.10"
-authors = [
-    { name = "Varun Pratap Bhardwaj" },
-]
-keywords = ["langchain", "memory", "local-first", "privacy", "sqlite", "chat-history", "mcp"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Topic :: Software Development :: Libraries",
-    "Topic :: Scientific/Engineering :: Artificial Intelligence",
-]
-dependencies = [
-    "langchain-core>=1.0.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/qualixar/superlocalmemory"
-Documentation = "https://superlocalmemory.com/"
-Repository = "https://github.com/qualixar/superlocalmemory"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]

package/ide/integrations/langchain/tests/__init__.py

@@ -1,3 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-or-later
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)