synapse-memory-engine 1.3.0__py3-none-any.whl

synapse_memory/integrations/langchain.py

@@ -0,0 +1,209 @@
+"""
+Production-grade LangChain drop-in memory integration for Synapse Memory.
+Compliant with langchain_core.memory.BaseMemory.
+"""
+
+from typing import Dict, Any, List, Optional
+import time
+import logging
+
+from synapse_memory.core.sqlite_db import SQLiteMemoryStore
+from synapse_memory.core.embedder import SynapseEmbedder
+from synapse_memory.core.memory_manager import MemoryManager
+from synapse_memory.core.hybrid_search import HybridSearch
+from synapse_memory.core.knapsack_packer import KnapsackPacker
+from synapse_memory.core.decay_engine import DecayEngine
+
+logger = logging.getLogger("SynapseLangChain")
+
+# Dynamic import for langchain_core with full schema parity fallback
+try:
+    from langchain_core.memory import BaseMemory
+    from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
+    HAS_LANGCHAIN = True
+except ImportError:
+    class BaseMemory:  # type: ignore[no-redef]
+        pass
+
+    class BaseMessage:  # type: ignore[no-redef]
+        def __init__(self, content: str):
+            self.content = content
+
+    class HumanMessage(BaseMessage):  # type: ignore[no-redef]
+        pass
+
+    class AIMessage(BaseMessage):  # type: ignore[no-redef]
+        pass
+
+    HAS_LANGCHAIN = False
+
+
+class SynapseLangChainMemory(BaseMemory):
+    """
+    Drop-in production memory module for LangChain chains and agents.
+    Inherits directly from langchain_core.memory.BaseMemory when available.
+
+    Features:
+    - Backed by persistent encrypted SQLite store.
+    - Automatic semantic deduplication on save_context.
+    - Real hybrid BM25 + dense vector search on load_memory_variables.
+    - Ebbinghaus continuous decay scoring.
+    - Exact Knapsack token budget packing into max_token_budget.
+    - Support for both string-formatted history and message list formats.
+    """
+
+    memory_key: str = "chat_history"
+    input_key: Optional[str] = None
+    output_key: Optional[str] = None
+    return_messages: bool = False
+    human_prefix: str = "Human"
+    ai_prefix: str = "AI"
+    max_token_budget: int = 2048
+
+    def __init__(
+        self,
+        memory_key: str = "chat_history",
+        input_key: Optional[str] = None,
+        output_key: Optional[str] = None,
+        return_messages: bool = False,
+        human_prefix: str = "Human",
+        ai_prefix: str = "AI",
+        max_token_budget: int = 2048,
+        db_path: str = ":memory:",
+        store: Optional[SQLiteMemoryStore] = None,
+        embedder: Optional[SynapseEmbedder] = None,
+        memory_manager: Optional[MemoryManager] = None,
+        **kwargs: Any
+    ):
+        if HAS_LANGCHAIN:
+            super().__init__(**kwargs)
+
+        self.memory_key = memory_key
+        self.input_key = input_key
+        self.output_key = output_key
+        self.return_messages = return_messages
+        self.human_prefix = human_prefix
+        self.ai_prefix = ai_prefix
+        self.max_token_budget = max_token_budget
+
+        # Initialize underlying Synapse core substrate
+        self.store = store or SQLiteMemoryStore(db_path=db_path)
+        self.embedder = embedder or SynapseEmbedder(provider="local")
+        self.manager = memory_manager or MemoryManager(
+            store=self.store,
+            embedder=self.embedder,
+            max_record_limit=kwargs.get("max_record_limit", 500)
+        )
+        self.searcher = HybridSearch(alpha=0.6, k=60)
+        self.packer = KnapsackPacker(token_budget=max_token_budget)
+        self.decay = DecayEngine()
+
+    @property
+    def memory_variables(self) -> List[str]:
+        """Exposes memory variables to LangChain prompt templates."""
+        return [self.memory_key]
+
+    def _get_input_output(
+        self, inputs: Dict[str, Any], outputs: Dict[str, Any]
+    ) -> tuple[str, str]:
+        if self.input_key:
+            user_input = inputs.get(self.input_key, "")
+        else:
+            prompt_keys = [k for k in inputs.keys() if k not in self.memory_variables]
+            user_input = str(inputs[prompt_keys[0]]) if prompt_keys else ""
+
+        if self.output_key:
+            model_output = outputs.get(self.output_key, "")
+        else:
+            out_keys = list(outputs.keys())
+            model_output = str(outputs[out_keys[0]]) if out_keys else ""
+
+        return str(user_input), str(model_output)
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Retrieves relevant historical memories, applies Ebbinghaus decay relevance scores,
+        solves context limits via Knapsack DP, and returns formatted context.
+        """
+        query_text = (
+            inputs.get("input")
+            or inputs.get("question")
+            or inputs.get("query")
+            or (inputs.get(self.input_key) if self.input_key else None)
+            or ""
+        )
+
+        all_memories = self.store.get_all_memories()
+        if not all_memories:
+            return {self.memory_key: [] if self.return_messages else ""}
+
+        # If query is provided, perform full Hybrid Search
+        if query_text.strip():
+            query_vector = self.embedder.embed_query(query_text)
+            ranked_nodes = self.searcher.search(
+                query=query_text,
+                corpus=all_memories,
+                query_vector=query_vector,
+                top_k=min(len(all_memories), 20)
+            )
+        else:
+            # Fallback to recency order if no active query
+            ranked_nodes = sorted(
+                all_memories,
+                key=lambda m: m.get("created_at", 0),
+                reverse=True
+            )[:20]
+
+        # Apply continuous temporal decay relevance scoring
+        now = time.time()
+        for node in ranked_nodes:
+            base_score = float(node.get("score", node.get("confidence", 0.8)))
+            node["relevance_score"] = self.decay.calculate_relevance(node, now=now) * base_score
+
+        # Solve Knapsack token constraint
+        packed_memories = self.packer.pack(ranked_nodes, token_budget=self.max_token_budget)
+
+        # Update access counters
+        for node in packed_memories:
+            self.store.update_access_count(node["id"], 1)
+
+        # Format output as messages or formatted string
+        if self.return_messages:
+            messages: List[Any] = []
+            for node in packed_memories:
+                content = node.get("content", "")
+                if " -> " in content and (self.human_prefix in content or "User:" in content):
+                    parts = content.split(" -> ", 1)
+                    u_text = parts[0].replace(f"{self.human_prefix}: ", "").replace("User: ", "")
+                    a_text = parts[1].replace(f"{self.ai_prefix}: ", "").replace("Agent: ", "").replace("AI: ", "")
+                    messages.append(HumanMessage(content=u_text))
+                    messages.append(AIMessage(content=a_text))
+                else:
+                    messages.append(HumanMessage(content=content))
+            return {self.memory_key: messages}
+        else:
+            formatted_nodes = [f"[{node.get('category', 'context').upper()}]: {node.get('content', '')}" for node in packed_memories]
+            return {self.memory_key: "\n".join(formatted_nodes)}
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, Any]) -> None:
+        """
+        Saves user/assistant conversation turn into encrypted memory store with deduplication.
+        """
+        user_input, model_output = self._get_input_output(inputs, outputs)
+        if not user_input and not model_output:
+            return
+
+        combined_content = f"{self.human_prefix}: {user_input} -> {self.ai_prefix}: {model_output}"
+
+        # Ingest through memory manager to trigger semantic deduplication and auto-pruning
+        self.manager.ingest_with_deduplication(
+            content=combined_content,
+            category="conversation",
+            confidence=0.95
+        )
+
+    def clear(self) -> None:
+        """Clears all stored memories."""
+        all_mems = self.store.get_all_memories()
+        for mem in all_mems:
+            self.store.delete_memory(mem["id"])

synapse_memory/integrations/llamaindex.py

@@ -0,0 +1,295 @@
+"""
+Production-grade LlamaIndex drop-in memory integration for Synapse Memory.
+Compliant with llama_index.core.memory.BaseMemory.
+"""
+
+from typing import Dict, Any, List, Optional
+import time
+import logging
+
+from synapse_memory.core.sqlite_db import SQLiteMemoryStore
+from synapse_memory.core.embedder import SynapseEmbedder
+from synapse_memory.core.memory_manager import MemoryManager
+from synapse_memory.core.hybrid_search import HybridSearch
+from synapse_memory.core.knapsack_packer import KnapsackPacker
+from synapse_memory.core.decay_engine import DecayEngine
+
+logger = logging.getLogger("SynapseLlamaIndex")
+
+try:
+    from llama_index.core.memory import BaseMemory
+    from llama_index.core.llms import ChatMessage, MessageRole
+    from llama_index.core.bridge.pydantic import Field, PrivateAttr
+    HAS_LLAMAINDEX = True
+except ImportError:
+    class BaseMemory:  # type: ignore[no-redef]  # noqa: F811
+        pass
+
+    def Field(default: Any = None, **kwargs: Any) -> Any:  # type: ignore[no-redef]  # noqa: F811
+        return default
+
+    def PrivateAttr(default: Any = None, **kwargs: Any) -> Any:  # type: ignore[no-redef]  # noqa: F811
+        return default
+
+    class MessageRole:  # type: ignore[no-redef]  # noqa: F811
+        USER = "user"
+        ASSISTANT = "assistant"
+        SYSTEM = "system"
+
+    class ChatMessage:  # type: ignore[no-redef]  # noqa: F811
+        def __init__(
+            self,
+            role: Any = MessageRole.USER,
+            content: str = "",
+            additional_kwargs: Optional[Dict[str, Any]] = None,
+        ):
+            self.role = role
+            self.content = content
+            self.additional_kwargs = additional_kwargs or {}
+
+        def __repr__(self) -> str:
+            return f"ChatMessage(role={self.role}, content={self.content[:30]}...)"
+
+    HAS_LLAMAINDEX = False
+
+
+class SynapseLlamaIndexMemory(BaseMemory):
+    """
+    Drop-in production memory module for LlamaIndex query and chat engines.
+    Inherits directly from llama_index.core.memory.BaseMemory when available.
+
+    Features:
+    - Backed by persistent encrypted SQLite store.
+    - Automatic semantic deduplication on message ingestion.
+    - Real hybrid BM25 + dense vector retrieval.
+    - Knapsack token packing within max_token_limit.
+    - Full ChatMessage role preservation.
+    """
+
+    max_token_limit: int = Field(default=3072)
+    db_path: str = Field(default=":memory:")
+    max_record_limit: int = Field(default=500)
+
+    _store: Optional[SQLiteMemoryStore] = PrivateAttr(default=None)
+    _embedder: Optional[SynapseEmbedder] = PrivateAttr(default=None)
+    _manager: Optional[MemoryManager] = PrivateAttr(default=None)
+    _searcher: Optional[HybridSearch] = PrivateAttr(default=None)
+    _packer: Optional[KnapsackPacker] = PrivateAttr(default=None)
+    _decay: Optional[DecayEngine] = PrivateAttr(default=None)
+
+    def __init__(
+        self,
+        max_token_limit: int = 3072,
+        db_path: str = ":memory:",
+        store: Optional[SQLiteMemoryStore] = None,
+        embedder: Optional[SynapseEmbedder] = None,
+        memory_manager: Optional[MemoryManager] = None,
+        max_record_limit: int = 500,
+        **kwargs: Any
+    ):
+        if HAS_LLAMAINDEX:
+            super().__init__(
+                max_token_limit=max_token_limit,
+                db_path=db_path,
+                max_record_limit=max_record_limit,
+                **kwargs,
+            )
+        else:
+            self.max_token_limit = max_token_limit
+            self.db_path = db_path
+            self.max_record_limit = max_record_limit
+
+        self._store = store or SQLiteMemoryStore(db_path=db_path)
+        self._embedder = embedder or SynapseEmbedder(provider="local")
+        self._manager = memory_manager or MemoryManager(
+            store=self.store,
+            embedder=self.embedder,
+            max_record_limit=kwargs.get("max_record_limit", max_record_limit),
+        )
+        self._searcher = HybridSearch(alpha=0.6, k=60)
+        self._packer = KnapsackPacker(token_budget=max_token_limit)
+        self._decay = DecayEngine()
+
+    @property
+    def store(self) -> SQLiteMemoryStore:
+        store = self._store
+        assert store is not None
+        return store
+
+    @store.setter
+    def store(self, value: SQLiteMemoryStore) -> None:
+        self._store = value
+
+    @property
+    def embedder(self) -> SynapseEmbedder:
+        embedder = self._embedder
+        assert embedder is not None
+        return embedder
+
+    @embedder.setter
+    def embedder(self, value: SynapseEmbedder) -> None:
+        self._embedder = value
+
+    @property
+    def manager(self) -> MemoryManager:
+        manager = self._manager
+        assert manager is not None
+        return manager
+
+    @manager.setter
+    def manager(self, value: MemoryManager) -> None:
+        self._manager = value
+
+    @property
+    def searcher(self) -> HybridSearch:
+        searcher = self._searcher
+        assert searcher is not None
+        return searcher
+
+    @searcher.setter
+    def searcher(self, value: HybridSearch) -> None:
+        self._searcher = value
+
+    @property
+    def packer(self) -> KnapsackPacker:
+        packer = self._packer
+        assert packer is not None
+        return packer
+
+    @packer.setter
+    def packer(self, value: KnapsackPacker) -> None:
+        self._packer = value
+
+    @property
+    def decay(self) -> DecayEngine:
+        decay = self._decay
+        assert decay is not None
+        return decay
+
+    @decay.setter
+    def decay(self, value: DecayEngine) -> None:
+        self._decay = value
+
+    @classmethod
+    def from_defaults(cls, **kwargs: Any) -> "SynapseLlamaIndexMemory":
+        """Create a memory instance from defaults (llama_index BaseMemory contract)."""
+        chat_history = kwargs.pop("chat_history", None)
+        instance = cls(**kwargs)
+        if chat_history:
+            for msg in chat_history:
+                instance.put(msg)
+        return instance
+
+    @staticmethod
+    def _role_value(role: Any) -> str:
+        value = getattr(role, "value", role)
+        return str(value) if value is not None else "user"
+
+    @staticmethod
+    def _content_text(content: Any) -> str:
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts: List[str] = []
+            for block in content:
+                if isinstance(block, str):
+                    parts.append(block)
+                elif isinstance(block, dict) and "text" in block:
+                    parts.append(str(block["text"]))
+                else:
+                    text = getattr(block, "text", None)
+                    parts.append(str(text) if text is not None else str(block))
+            return "".join(parts)
+        return str(content) if content is not None else ""
+
+    def _to_canonical_role(self, role: Any) -> str:
+        normalized = self._role_value(role).lower()
+        if normalized in ("user", "assistant", "system"):
+            return normalized
+        return "user"
+
+    def get(self, input: Optional[str] = None, **kwargs: Any) -> List[ChatMessage]:  # type: ignore[override]
+        """
+        Retrieves relevant historical chat messages, applying hybrid search and knapsack packing.
+        """
+        all_memories = self.store.get_all_memories()
+        if not all_memories:
+            return []
+
+        if input and input.strip():
+            query_vector = self.embedder.embed_query(input)
+            ranked_nodes = self.searcher.search(
+                query=input,
+                corpus=all_memories,
+                query_vector=query_vector,
+                top_k=min(len(all_memories), 20)
+            )
+        else:
+            ranked_nodes = sorted(
+                all_memories,
+                key=lambda m: m.get("created_at", 0),
+                reverse=True
+            )[:20]
+
+        now = time.time()
+        for node in ranked_nodes:
+            base_score = float(node.get("score", node.get("confidence", 0.8)))
+            node["relevance_score"] = self.decay.calculate_relevance(node, now=now) * base_score
+
+        packed_memories = self.packer.pack(ranked_nodes, token_budget=self.max_token_limit)
+
+        messages: List[ChatMessage] = []
+        for node in packed_memories:
+            self.store.update_access_count(node["id"], 1)
+            content = node.get("content", "")
+            role = self._to_canonical_role(node.get("category", "user"))
+            messages.append(ChatMessage(role=role, content=content))  # type: ignore[arg-type]
+
+        return messages
+
+    def get_all(self) -> List[ChatMessage]:
+        """Returns all messages currently persisted in the memory store."""
+        all_memories = sorted(
+            self.store.get_all_memories(),
+            key=lambda m: m.get("created_at", 0),
+        )
+        messages: List[ChatMessage] = []
+        for node in all_memories:
+            role = self._to_canonical_role(node.get("category", "user"))
+            messages.append(ChatMessage(role=role, content=node.get("content", "")))  # type: ignore[arg-type]
+        return messages
+
+    def put(self, message: Any) -> None:  # type: ignore[override]
+        """
+        Stores a ChatMessage (or plain text) into the encrypted store with semantic deduplication.
+        """
+        if isinstance(message, ChatMessage):
+            content = self._content_text(message.content)
+            role = self._to_canonical_role(message.role)
+        elif isinstance(message, dict):
+            content = self._content_text(message.get("content", ""))
+            role = self._to_canonical_role(message.get("role", "user"))
+        else:
+            content = self._content_text(message)
+            role = "user"
+
+        if not content.strip():
+            return
+
+        self.manager.ingest_with_deduplication(
+            content=content,
+            category=role,
+            confidence=0.95
+        )
+
+    def set(self, messages: List[Any]) -> None:  # type: ignore[override]
+        """Resets the store and inserts the provided message sequence."""
+        self.reset()
+        for msg in messages:
+            self.put(msg)
+
+    def reset(self) -> None:  # type: ignore[override]
+        """Clears all stored memories."""
+        all_mems = self.store.get_all_memories()
+        for mem in all_mems:
+            self.store.delete_memory(mem["id"])

synapse_memory/main.py

@@ -0,0 +1,112 @@
+import time
+from synapse_memory.core.knapsack_packer import KnapsackPacker
+from synapse_memory.core.decay_engine import DecayEngine
+from synapse_memory.core.hybrid_search import HybridSearch
+
+
+def run_production_demo():
+    print("=" * 70)
+    print("      SYNAPSEMEMORY: UNIVERSAL ACTIVE RAG CORE DEMO & TESTS")
+    print("=" * 70)
+
+    # 1. Initialize Engines
+    packer = KnapsackPacker()
+    decay = DecayEngine()
+    search = HybridSearch()
+
+    print("\n[+] Engines Initialized Successfully:")
+    print("    - Knapsack Packer: Adaptive 0/1 Dynamic Programming Solver Active")
+    print("    - Temporal Decay: Ebbinghaus Stabilization Curve Active")
+    print("    - Hybrid Search: Lexical/Semantic Reciprocal Fusion Active")
+
+    # 2. Ingest Sample Memory Base representing typical user developer workspace config
+    database = [
+        {
+            "id": "mem_01",
+            "content": "User prefers React with TypeScript and uses Vite with Tailwind CSS for layouts. Absolutely bans inline style tags.",
+            "category": "preference",
+            "confidence": 0.98,
+            "created_at": time.time() - 3600,  # 1 hour ago
+            "access_count": 0,
+            "token_cost": 35
+        },
+        {
+            "id": "mem_02",
+            "content": "AetherLab database uses PostgreSQL hosted on GCP Cloud SQL with pgvector extensions configured.",
+            "category": "infrastructure",
+            "confidence": 0.95,
+            "created_at": time.time() - 86400 * 2,  # 2 days ago (should show significant temporal decay)
+            "access_count": 0,
+            "token_cost": 40
+        },
+        {
+            "id": "mem_03",
+            "content": "Server is listening exclusively on port 3000 behind an Nginx reverse proxy layer.",
+            "category": "infrastructure",
+            "confidence": 0.96,
+            "created_at": time.time(),  # just now (high freshness)
+            "access_count": 0,
+            "token_cost": 25
+        },
+        {
+            "id": "mem_04",
+            "content": "User hates purple-to-blue gradients in UI design. Prefers highly-polished warm or cool slate neutrals.",
+            "category": "preference",
+            "confidence": 0.92,
+            "created_at": time.time() - 10,  # just now
+            "access_count": 0,
+            "token_cost": 30
+        }
+    ]
+
+    print(f"\n[+] Ingested {len(database)} Sample Cognitive Nodes into Memory Store.")
+
+    # 3. Simulate Query and Dynamic Filtering
+    query = "What framework and styling settings should we use for database infrastructure?"
+    print(f"\n[?] User Prompt: '{query}'")
+
+    print("\n[~] Execution Phase 1: Running Hybrid Semantic/Lexical Retrieval...")
+    candidates = search.fused_search(query, database, top_k=4)
+
+    print("\n[~] Execution Phase 2: Applying Ebbinghaus Temporal Forgetting Curve Weights...")
+    decayed_candidates = []
+    for c in candidates:
+        original_score = c["relevance_score"]
+        current_score = decay.calculate_retention(
+            base_relevance=original_score,
+            created_epoch=c["created_at"],
+            access_count=c["access_count"]
+        )
+        c_copy = c.copy()
+        c_copy["relevance_score"] = current_score
+        decayed_candidates.append(c_copy)
+
+        # Display computed weight variations
+        print(f"    - Node {c['id']}: Orig Search Relevance={original_score:.3f} | Current Decay Score={current_score:.3f}")
+
+    # 4. Solve Knapsack token allocation to fit within a strict token context budget
+    token_budget = 70  # deliberately tight budget to force knapsack decision optimization
+    print(f"\n[~] Execution Phase 3: Solving Knapsack DP Constraint (Budget: {token_budget} tokens)...")
+    packed_memories = packer.pack(decayed_candidates, token_budget)
+
+    print("\n" + "-" * 70)
+    print("      SYNAPSEMEMORY CONTEXT BUDGET ALLOCATION REPORT")
+    print("-" * 70)
+    print(f"Total Database Candidates Size : {sum(d['token_cost'] for d in database)} tokens")
+    print(f"Target Prompt Context Budget   : {token_budget} tokens")
+    print(f"Optimal Allocation Pack Size   : {sum(m['token_cost'] for m in packed_memories)} tokens")
+    print(f"Total Overhead Costs Saved     : {sum(d['token_cost'] for d in database) - sum(m['token_cost'] for m in packed_memories)} tokens")
+    print("-" * 70)
+
+    print("\n[+] Selected Context Pack Nodes:")
+    for idx, node in enumerate(packed_memories):
+        print(f"  {idx + 1}. [{node['id']}] Category: {node['category'].upper()} | Cost: {node['token_cost']} tokens | Final Relevance: {node['relevance_score']:.3f}")
+        print(f"     Content: \"{node['content']}\"")
+
+    print("\n" + "=" * 70)
+    print("      DEMONSTRATION RUN COMPLETE - STATUS: PRODUCTION READY")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    run_production_demo()

synapse_memory_engine-1.3.0.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: synapse-memory-engine
+Version: 1.3.0
+Summary: Production-grade active RAG & cognitive memory engine with multi-tenancy, pgvector HNSW indexing, semantic deduplication, decay-based pruning, and token-aware context packing.
+Home-page: https://github.com/721189/Synapse-Memory
+Author: Synapse Cognitive Systems
+Author-email: Synapse Cognitive Systems <singhshivam20009@gmail.com>
+Project-URL: Homepage, https://github.com/721189/Synapse-Memory
+Project-URL: Bug Tracker, https://github.com/721189/Synapse-Memory/issues
+Project-URL: Documentation, https://github.com/721189/Synapse-Memory#readme
+Project-URL: Repository, https://github.com/721189/Synapse-Memory.git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: uvicorn>=0.34.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: urllib3>=2.8.0
+Provides-Extra: local-models
+Requires-Dist: sentence-transformers>=5.0.0; extra == "local-models"
+Provides-Extra: pgvector
+Requires-Dist: psycopg2-binary>=2.9.9.1; extra == "pgvector"
+Requires-Dist: pgvector>=0.4.0; extra == "pgvector"
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == "redis"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.13.0; extra == "llamaindex"
+Provides-Extra: all
+Requires-Dist: sentence-transformers>=5.0.0; extra == "all"
+Requires-Dist: psycopg2-binary>=2.9.9.1; extra == "all"
+Requires-Dist: pgvector>=0.4.0; extra == "all"
+Requires-Dist: langchain-core>=0.3.0; extra == "all"
+Requires-Dist: llama-index-core>=0.13.0; extra == "all"
+Requires-Dist: redis>=5.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: flake8>=7.0.0; extra == "dev"
+Requires-Dist: mypy>=1.13.0; extra == "dev"
+Requires-Dist: bandit>=1.8.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"
+Requires-Dist: types-requests>=2.32.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Synapse Memory Python SDK
+
+Core Python SDK and algorithms for the Synapse Cognitive Memory substrate.
+
+## Features
+
+- **Encrypted SQLite Storage**: Fernet AES-128-CBC with HMAC-SHA256 authenticated encryption at rest.
+- **Dynamic Programming Knapsack Packing**: Exact 0/1 Knapsack optimizer for packing high-relevance memories into strict token envelopes.
+- **Ebbinghaus Decay Engine**: Continuous temporal decay with positive/negative reinforcement factors.
+- **Semantic Deduplication**: Dual lexical Jaccard and dense cosine similarity detection to prevent node fragmentation.
+- **Hybrid Retrieval**: BM25 sparse lexical ranking fused with dense vector embeddings via Reciprocal Rank Fusion (RRF).
+- **Framework Integrations**: True drop-in adapters for LangChain (`BaseMemory`) and LlamaIndex (`BaseMemory`).
+
+## Installation
+
+```bash
+pip install synapse-memory-engine          # from PyPI
+# or, from a checkout of this repository:
+pip install -e .
+```
+
+## Testing
+
+```bash
+python3 -m unittest discover -s tests
+```