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

synapse_memory/cli/synapse_cli.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+import os
+
+# Align python sys path to resolve absolute imports correctly
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from synapse_memory.core.decay_engine import DecayEngine
+from synapse_memory.core.embedder import SynapseEmbedder
+from synapse_memory.core.hybrid_search import HybridSearch
+from synapse_memory.core.knapsack_packer import KnapsackPacker
+from synapse_memory.core.memory_manager import MemoryManager
+from synapse_memory.core.sqlite_db import SQLiteMemoryStore
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="SynapseMemory: Sovereign Command-Line Cognitive Console & Debugger."
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # Ingest subcommand
+    ingest_parser = subparsers.add_parser("ingest", help="Ingest a cognitive memory segment with semantic deduplication")
+    ingest_parser.add_argument("--content", required=True, type=str, help="Text content of the memory")
+    ingest_parser.add_argument("--category", type=str, default="interaction", help="Cognitive category")
+    ingest_parser.add_argument("--confidence", type=float, default=0.95, help="Confidence factor (0.0 to 1.0)")
+
+    # Query subcommand
+    query_parser = subparsers.add_parser("query", help="Query long-term memory with Knapsack context budget constraints")
+    query_parser.add_argument("--prompt", required=True, type=str, help="The search or context prompt")
+    query_parser.add_argument("--budget", type=int, default=1500, help="Maximum tokens allowed in context pack")
+
+    # List subcommand
+    subparsers.add_parser("list", help="List all indexed sqlite memories")
+
+    # Clear subcommand
+    subparsers.add_parser("clear", help="Clear the entire local SQLite memory table")
+
+    # Prune subcommand
+    prune_parser = subparsers.add_parser("prune", help="Manually force a temporal Ebbinghaus decay pruning sweep")
+    prune_parser.add_argument("--limit", type=int, default=10, help="Set database maximum record limit")
+
+    args = parser.parse_args()
+
+    # Initialize store, embedder and engines
+    store = SQLiteMemoryStore("synapse_memory.db")
+    embedder = SynapseEmbedder(provider="local")
+    manager = MemoryManager(store=store, embedder=embedder)
+    searcher = HybridSearch()
+    decay = DecayEngine()
+    packer = KnapsackPacker()
+
+    if args.command == "ingest":
+        mem_id, action, cost = manager.ingest_with_deduplication(
+            content=args.content,
+            category=args.category,
+            confidence=args.confidence
+        )
+        print("[+] Ingestion Finished:")
+        print(f"    - Memory ID  : {mem_id}")
+        print(f"    - Event Type : {action}")
+        print(f"    - Token Cost : {cost} tokens")
+
+    elif args.command == "query":
+        memories = store.get_all_memories()
+        if not memories:
+            print("[-] Store is empty. Ingest memories before querying.")
+            return
+
+        candidates = searcher.fused_search(args.prompt, memories, top_k=25)
+
+        # Apply temporal decay calculations
+        decayed = []
+        for c in candidates:
+            current = decay.calculate_retention(
+                base_relevance=c["relevance_score"],
+                created_epoch=c["created_at"],
+                access_count=c["access_count"]
+            )
+            c_copy = c.copy()
+            c_copy["relevance_score"] = current
+            decayed.append(c_copy)
+
+        packed = packer.pack(decayed, args.budget)
+
+        print(f"\n[+] Retained {len(packed)} optimal context segments under a {args.budget}-token budget:")
+        for idx, m in enumerate(packed):
+            print(f"  {idx + 1}. [{m['id']}] (Cost: {m['token_cost']} tokens, Relevance: {m['relevance_score']:.3f}):")
+            print(f"     \"{m['content']}\"")
+
+    elif args.command == "list":
+        memories = store.get_all_memories()
+        print(f"[+] Active Database Records ({len(memories)} items):")
+        for m in memories:
+            print(f"  - [{m['id']}] Category: {m['category'].upper()} | Cost: {m['token_cost']} | Content: \"{m['content'][:60]}...\"")
+
+    elif args.command == "clear":
+        os.remove("synapse_memory.db") if os.path.exists("synapse_memory.db") else None
+        print("[+] Erased local sqlite database table cleanly.")
+
+    elif args.command == "prune":
+        manager.max_record_limit = args.limit
+        evicted = manager.auto_prune_store()
+        print(f"[+] Manual Prune Complete: Evicted {evicted} memories. Active store contains max {args.limit} items.")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

synapse_memory/client.py

@@ -0,0 +1,127 @@
+"""Canonical SynapseMemory Python client (Phase 6.1).
+
+Small, typed surface over the REST gateway — the supported path for
+external applications. Handles auth headers, timeouts, retries on
+retryable (429/5xx) failures, and the canonical {success, data} envelope.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import requests
+
+__all__ = ["SynapseClient", "SynapseError", "CreateResult", "QueryResult"]
+
+SDK_VERSION = "1.2.0"
+API_COMPAT_VERSION = "v1"
+
+
+class SynapseError(Exception):
+    def __init__(self, message: str, *, status: Optional[int] = None, retryable: bool = False):
+        super().__init__(message)
+        self.status = status
+        self.retryable = retryable
+
+
+@dataclass
+class CreateResult:
+    id: str
+    status: str
+    token_cost: int
+    tenant_id: str
+
+
+@dataclass
+class QueryResult:
+    fused_context: str
+    injected_nodes_count: int
+    injected_nodes: List[Dict[str, Any]]
+    storage_backend: str
+
+
+class SynapseClient:
+    """Synchronous client; also usable as a context manager."""
+
+    def __init__(
+        self,
+        base_url: str = "http://127.0.0.1:8008",
+        api_key: Optional[str] = None,
+        tenant_id: str = "default",
+        timeout: float = 10.0,
+        max_retries: int = 3,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.tenant_id = tenant_id
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._session = requests.Session()
+
+    def __enter__(self) -> "SynapseClient":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._session.close()
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json", "X-Tenant-ID": self.tenant_id}
+        if self.api_key:
+            headers["X-Synapse-API-Key"] = self.api_key
+        return headers
+
+    def _request(self, method: str, path: str, payload: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        last_error: Optional[SynapseError] = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = self._session.request(method, url, json=payload, headers=self._headers(), timeout=self.timeout)
+            except requests.RequestException as e:
+                last_error = SynapseError(f"Connection failed: {e}", retryable=True)
+            else:
+                if resp.status_code in (429, 502, 503, 504):
+                    last_error = SynapseError(f"Retryable {resp.status_code}: {resp.text[:200]}", status=resp.status_code, retryable=True)
+                elif not resp.ok:
+                    raise SynapseError(f"Request failed {resp.status_code}: {resp.text[:500]}", status=resp.status_code)
+                else:
+                    body = resp.json()
+                    if isinstance(body, dict) and "success" in body and "data" in body:
+                        if not body["success"]:
+                            raise SynapseError(f"API error: {body.get('error')}", status=resp.status_code)
+                        return body["data"]
+                    return body
+            if attempt < self.max_retries:
+                time.sleep(min(2.0, 0.25 * (2 ** attempt)))
+        raise last_error or SynapseError("Request failed")
+
+    def create_memory(self, content: str, category: str = "interaction", confidence: float = 0.95) -> CreateResult:
+        data = self._request("POST", "/ingest", {"content": content, "category": category, "confidence": confidence})
+        return CreateResult(id=data["id"], status=data["status"], token_cost=data["token_cost"], tenant_id=data["tenant_id"])
+
+    def retrieve(self, query: str, max_tokens: int = 1500) -> QueryResult:
+        data = self._request("POST", "/query", {"prompt": query, "maxTokens": max_tokens})
+        return QueryResult(
+            fused_context=data.get("fused_context", ""),
+            injected_nodes_count=data.get("injected_nodes_count", 0),
+            injected_nodes=data.get("injected_nodes", []),
+            storage_backend=data.get("active_storage_backend", "unknown"),
+        )
+
+    def list_memories(self, limit: int = 50, offset: int = 0) -> Dict[str, Any]:
+        return self._request("GET", f"/api/memories/list?limit={limit}&offset={offset}")
+
+    def delete_memory(self, memory_id: str) -> Dict[str, Any]:
+        return self._request("DELETE", f"/api/memories/{memory_id}")
+
+    def feedback(self, memory_id: str, feedback_type: str) -> Dict[str, Any]:
+        return self._request("POST", "/feedback", {"memory_id": memory_id, "feedback_type": feedback_type})
+
+    def health(self) -> Dict[str, Any]:
+        return self._request("GET", "/health")
+
+    def readiness(self) -> Dict[str, Any]:
+        return self._request("GET", "/readiness")

synapse_memory/core/__init__.py

@@ -0,0 +1,50 @@
+# Expose core components for internal and public access
+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, MemoryNodeResult
+from synapse_memory.core.decay_engine import DecayEngine
+from synapse_memory.core.deduplicator import Deduplicator, Action, DeduplicationResult
+from synapse_memory.core.pruner import (
+    PruningEngine,
+    CapacityPruningPolicy,
+    TTLPruningPolicy,
+    ConfidencePruningPolicy,
+)
+from synapse_memory.core.embedding_provider import (
+    EmbeddingManager,
+    LocalEmbeddingProvider,
+    GeminiEmbeddingProvider,
+    OpenAIEmbeddingProvider,
+)
+from synapse_memory.core.encryption import EncryptedMemoryStore, FernetKeyManager
+from synapse_memory.core.pgvector_db import PGVectorMemoryStore
+from synapse_memory.core.auth import SecurityManager, APIKeyRecord, AuthAuditLog
+
+__all__ = [
+    "SQLiteMemoryStore",
+    "PGVectorMemoryStore",
+    "SecurityManager",
+    "APIKeyRecord",
+    "AuthAuditLog",
+    "SynapseEmbedder",
+    "MemoryManager",
+    "HybridSearch",
+    "KnapsackPacker",
+    "MemoryNodeResult",
+    "DecayEngine",
+    "Deduplicator",
+    "Action",
+    "DeduplicationResult",
+    "PruningEngine",
+    "CapacityPruningPolicy",
+    "TTLPruningPolicy",
+    "ConfidencePruningPolicy",
+    "EmbeddingManager",
+    "LocalEmbeddingProvider",
+    "GeminiEmbeddingProvider",
+    "OpenAIEmbeddingProvider",
+    "EncryptedMemoryStore",
+    "FernetKeyManager",
+]