synapsemem-ai 0.1.0__tar.gz

synapsemem_ai-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: synapsemem-ai
+Version: 0.1.0
+Summary: A zero-overhead, temporal belief-graph memory engine for local AI agents.
+Author: Rohan Dhar
+Project-URL: Homepage, https://github.com/rohandhar6824/SynapseMem
+Project-URL: Bug Tracker, https://github.com/rohandhar6824/SynapseMem/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ollama>=0.1.0
+Dynamic: license-file
+
+# ⚡ SynapseMem
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Hardware](https://img.shields.io/badge/Hardware-Edge%20%2F%20CPU%20Friendly-green)](#benchmarks)
+
+**SynapseMem** is a lightweight, zero-dependency, temporal belief-graph memory engine designed to eliminate **chronological amnesia** and context bloat in small, local language models (SLMs).
+
+Traditional Vector RAG dumps conflicting raw chunks into the prompt context, degrading accuracy and slowing down CPU inference. SynapseMem converts interactions into atomic beliefs, deterministically resolves state transitions over time, and injects clean, conflict-free context into edge models.
+
+---
+
+## 🔬 The Problem: Chronological Amnesia in RAG
+
+When an autonomous agent runs over days or weeks, states drift:
+* **Monday:** `"The production server is on port 8000."`
+* **Friday:** `"We migrated the server to port 9090."`
+
+Standard vector similarity retrieves **both** chunks with equal semantic weight. A 3B parameter model given both inputs often hallucinates stale data.

synapsemem_ai-0.1.0/README.md

@@ -0,0 +1,19 @@
+# ⚡ SynapseMem
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Hardware](https://img.shields.io/badge/Hardware-Edge%20%2F%20CPU%20Friendly-green)](#benchmarks)
+
+**SynapseMem** is a lightweight, zero-dependency, temporal belief-graph memory engine designed to eliminate **chronological amnesia** and context bloat in small, local language models (SLMs).
+
+Traditional Vector RAG dumps conflicting raw chunks into the prompt context, degrading accuracy and slowing down CPU inference. SynapseMem converts interactions into atomic beliefs, deterministically resolves state transitions over time, and injects clean, conflict-free context into edge models.
+
+---
+
+## 🔬 The Problem: Chronological Amnesia in RAG
+
+When an autonomous agent runs over days or weeks, states drift:
+* **Monday:** `"The production server is on port 8000."`
+* **Friday:** `"We migrated the server to port 9090."`
+
+Standard vector similarity retrieves **both** chunks with equal semantic weight. A 3B parameter model given both inputs often hallucinates stale data.

synapsemem_ai-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "synapsemem-ai"
+version = "0.1.0"
+authors = [
+  { name="Rohan Dhar" }
+]
+description = "A zero-overhead, temporal belief-graph memory engine for local AI agents."
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "ollama>=0.1.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/rohandhar6824/SynapseMem"
+"Bug Tracker" = "https://github.com/rohandhar6824/SynapseMem/issues"

synapsemem_ai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

synapsemem_ai-0.1.0/synapsemem/__init__.py

@@ -0,0 +1,3 @@
+from .engine import SynapseMemoryEngine, BeliefNode
+
+__all__ = ["SynapseMemoryEngine", "BeliefNode"]

synapsemem_ai-0.1.0/synapsemem/bridge.py

@@ -0,0 +1,119 @@
+import ollama
+import json
+import time
+import re
+from synapse_core import SynapseMemoryEngine
+
+memory = SynapseMemoryEngine()
+MODEL = "qwen2.5:3b"
+
+QUESTION_STARTERS = (
+    "what", "when", "where", "which", "who", "whom", "whose", 
+    "why", "how", "is", "are", "was", "were", "do", "does", 
+    "did", "can", "could", "should", "would", "tell me"
+)
+
+def is_query_only(text: str) -> bool:
+    """Detects if an input is purely a question to avoid state poisoning."""
+    cleaned = text.strip().lower()
+    if cleaned.endswith("?"):
+        return True
+    return any(cleaned.startswith(w + " ") or cleaned == w for w in QUESTION_STARTERS)
+
+def extract_triplets(user_text: str) -> list:
+    """Extracts facts only from declarative statements."""
+    system_prompt = (
+        "Extract new factual declarations from the user text as JSON: {\"facts\": [{\"subject\": ..., \"predicate\": ..., \"object\": ...}]}.\n"
+        "RULES:\n"
+        "- Only extract facts if the user is making a clear, declarative statement.\n"
+        "- If the text is a question, query, or lacks concrete statements, return {\"facts\": []}.\n"
+        "- Keep predicates short (e.g., 'uses_port', 'has_status')."
+    )
+    
+    try:
+        response = ollama.chat(
+            model=MODEL,
+            messages=[
+                {'role': 'system', 'content': system_prompt},
+                {'role': 'user', 'content': user_text}
+            ],
+            format='json'
+        )
+        data = json.loads(response['message']['content'])
+        
+        if isinstance(data, dict):
+            for key in ['facts', 'triplets', 'data', 'items']:
+                if key in data and isinstance(data[key], list):
+                    return data[key]
+            if 'subject' in data and 'predicate' in data and 'object' in data:
+                return [data]
+            return []
+        elif isinstance(data, list):
+            return data
+        return []
+    except Exception as e:
+        print(f"[Extractor Debug] Parse error: {e}")
+        return []
+
+def chat_with_memory():
+    print(f"SynapseMem Agent Online using {MODEL}. Type 'exit' to quit.\n" + "="*55)
+    
+    while True:
+        user_input = input("\nYou: ").strip()
+        if not user_input:
+            continue
+        if user_input.lower() in ['exit', 'quit']:
+            break
+            
+        t_now = time.time()
+        
+        # 1. State Mutation Gate: Only extract if it is NOT a read-only query
+        if is_query_only(user_input):
+            print("[Read-Only Query: Memory ingestion skipped]")
+        else:
+            triplets = extract_triplets(user_input)
+            if triplets:
+                print(f"[Extracted {len(triplets)} fact(s)]")
+                for t in triplets:
+                    if isinstance(t, dict) and all(k in t for k in ['subject', 'predicate', 'object']):
+                        print("  " + memory.ingest_belief(str(t['subject']), str(t['predicate']), str(t['object']), now=t_now))
+            else:
+                print("[Extracted 0 facts]")
+
+        # 2. Context Retrieval (Strip punctuation)
+        tokens = re.findall(r'\b[a-zA-Z0-9_]+\b', user_input.lower())
+        retrieved_segments = []
+        for token in tokens:
+            if len(token) >= 3:
+                ctx = memory.retrieve_active_context(token, now=t_now)
+                if "(None)" not in ctx:
+                    retrieved_segments.append(ctx)
+                     
+        injected_context = "\n\n".join(sorted(set(retrieved_segments)))
+        
+        # 3. Prompt Construction
+        if injected_context:
+            prompt = (
+                f"Use this verified system memory to answer the user query.\n\n"
+                f"{injected_context}\n\n"
+                f"User Question: {user_input}"
+            )
+        else:
+            prompt = user_input
+            
+        print("\n[Thinking with Context...]")
+        response = ollama.chat(
+            model=MODEL,
+            messages=[
+                {
+                    'role': 'system', 
+                    'content': "You are an accurate technical assistant. Rely strictly on the provided verified system memory for factual questions."
+                },
+                {'role': 'user', 'content': prompt}
+            ]
+        )
+        
+        print(f"\nAgent: {response['message']['content']}")
+
+if __name__ == "__main__":
+    chat_with_memory()

synapsemem_ai-0.1.0/synapsemem/engine.py

@@ -0,0 +1,140 @@
+import time
+import math
+import sqlite3
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+
+@dataclass
+class BeliefNode:
+    subject: str
+    predicate: str
+    obj: str
+    created_at: float
+    last_accessed: float
+    strength: float = 1.0
+    is_active: bool = True
+    superseded_by: Optional[str] = None
+
+    def retention_score(self, current_time: float, decay_rate: float = 0.05) -> float:
+        if not self.is_active:
+            return 0.0
+        elapsed_hours = max(0.0, (current_time - self.last_accessed) / 3600.0)
+        effective_stability = self.strength / decay_rate
+        return math.exp(-elapsed_hours / effective_stability)
+
+
+class SynapseMemoryEngine:
+    def __init__(self, db_path: str = "synapse_memory.db", plural_predicates: Optional[set] = None):
+        self.db_path = db_path
+        self.plural_predicates = plural_predicates or {
+            "has_tag", "contains", "includes", "depends_on", "has_member", "features"
+        }
+        self._init_db()
+
+    def _init_db(self):
+        """Initializes the persistent SQLite schema."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS beliefs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    subject TEXT NOT NULL,
+                    predicate TEXT NOT NULL,
+                    object TEXT NOT NULL,
+                    created_at REAL NOT NULL,
+                    last_accessed REAL NOT NULL,
+                    strength REAL NOT NULL,
+                    is_active INTEGER NOT NULL,
+                    superseded_by TEXT
+                )
+            """)
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_subj_pred ON beliefs(subject, predicate)")
+            conn.commit()
+
+    def _is_singular(self, predicate: str) -> bool:
+        if predicate in self.plural_predicates:
+            return False
+        state_prefixes = ("is", "has_", "uses_", "deployed_", "current_", "set_")
+        return predicate.startswith(state_prefixes) or predicate.endswith(("_status", "_port", "_id"))
+
+    def ingest_belief(self, subject: str, predicate: str, obj: str, now: Optional[float] = None) -> str:
+        now = now or time.time()
+        subj_norm = subject.strip().lower()
+        pred_norm = predicate.strip().lower()
+        obj_norm = obj.strip()
+        is_singular = self._is_singular(pred_norm)
+
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Check for existing active beliefs
+            cursor.execute("""
+                SELECT id, object, strength FROM beliefs 
+                WHERE subject = ? AND predicate = ? AND is_active = 1
+            """, (subj_norm, pred_norm))
+            active_rows = cursor.fetchall()
+
+            for row_id, existing_obj, strength in active_rows:
+                # Reinforce exact match
+                if existing_obj.lower() == obj_norm.lower():
+                    new_strength = strength + 1.0
+                    cursor.execute("""
+                        UPDATE beliefs SET last_accessed = ?, strength = ? WHERE id = ?
+                    """, (now, new_strength, row_id))
+                    conn.commit()
+                    return f"[REINFORCED] ({subj_norm}, {pred_norm}, {existing_obj}) | Strength: {new_strength:.1f}"
+                
+                # Supersede old value if singular
+                elif is_singular:
+                    cursor.execute("""
+                        UPDATE beliefs SET is_active = 0, superseded_by = ? WHERE id = ?
+                    """, (obj_norm, row_id))
+
+            # Insert new active belief
+            cursor.execute("""
+                INSERT INTO beliefs (subject, predicate, object, created_at, last_accessed, strength, is_active, superseded_by)
+                VALUES (?, ?, ?, ?, ?, 1.0, 1, NULL)
+            """, (subj_norm, pred_norm, obj_norm, now, now))
+            conn.commit()
+            return f"[COMMITTED]  ({subj_norm}, {pred_norm}, {obj_norm})"
+
+    def retrieve_active_context(self, entity_query: str, min_retention: float = 0.2, now: Optional[float] = None) -> str:
+        now = now or time.time()
+        query_norm = entity_query.strip().lower()
+        active_facts = []
+        historical_shifts = []
+
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            # Find any records touching this entity
+            cursor.execute("""
+                SELECT id, subject, predicate, object, created_at, last_accessed, strength, is_active, superseded_by
+                FROM beliefs
+                WHERE subject LIKE ? OR object LIKE ?
+            """, (f"%{query_norm}%", f"%{query_norm}%"))
+            rows = cursor.fetchall()
+
+            for row in rows:
+                r_id, subj, pred, obj_val, c_at, l_acc, strength, is_active, superseded = row
+                node = BeliefNode(subj, pred, obj_val, c_at, l_acc, strength, bool(is_active), superseded)
+                
+                if node.is_active:
+                    score = node.retention_score(now)
+                    if score >= min_retention:
+                        # Touch access time in DB
+                        cursor.execute("UPDATE beliefs SET last_accessed = ? WHERE id = ?", (now, r_id))
+                        active_facts.append(f"- {subj} {pred} {obj_val}")
+                elif node.superseded_by:
+                    historical_shifts.append(f"- [PAST] {subj} {pred} was '{obj_val}' (now '{node.superseded_by}')")
+            conn.commit()
+
+        context_lines = ["### VERIFIED ACTIVE MEMORY:"] + (active_facts or ["(None)"])
+        if historical_shifts:
+            context_lines += ["\n### RESOLVED STATE CHANGES (DO NOT USE OLD VALUES):"] + historical_shifts[-4:]
+        return "\n".join(context_lines)
+
+    def reset_memory(self):
+        """Utility to wipe database for clean benchmarking."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.cursor().execute("DROP TABLE IF EXISTS beliefs")
+        self._init_db()

synapsemem_ai-0.1.0/synapsemem_ai.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: synapsemem-ai
+Version: 0.1.0
+Summary: A zero-overhead, temporal belief-graph memory engine for local AI agents.
+Author: Rohan Dhar
+Project-URL: Homepage, https://github.com/rohandhar6824/SynapseMem
+Project-URL: Bug Tracker, https://github.com/rohandhar6824/SynapseMem/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ollama>=0.1.0
+Dynamic: license-file
+
+# ⚡ SynapseMem
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Hardware](https://img.shields.io/badge/Hardware-Edge%20%2F%20CPU%20Friendly-green)](#benchmarks)
+
+**SynapseMem** is a lightweight, zero-dependency, temporal belief-graph memory engine designed to eliminate **chronological amnesia** and context bloat in small, local language models (SLMs).
+
+Traditional Vector RAG dumps conflicting raw chunks into the prompt context, degrading accuracy and slowing down CPU inference. SynapseMem converts interactions into atomic beliefs, deterministically resolves state transitions over time, and injects clean, conflict-free context into edge models.
+
+---
+
+## 🔬 The Problem: Chronological Amnesia in RAG
+
+When an autonomous agent runs over days or weeks, states drift:
+* **Monday:** `"The production server is on port 8000."`
+* **Friday:** `"We migrated the server to port 9090."`
+
+Standard vector similarity retrieves **both** chunks with equal semantic weight. A 3B parameter model given both inputs often hallucinates stale data.

synapsemem_ai-0.1.0/synapsemem_ai.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+synapsemem/__init__.py
+synapsemem/bridge.py
+synapsemem/engine.py
+synapsemem_ai.egg-info/PKG-INFO
+synapsemem_ai.egg-info/SOURCES.txt
+synapsemem_ai.egg-info/dependency_links.txt
+synapsemem_ai.egg-info/requires.txt
+synapsemem_ai.egg-info/top_level.txt

synapsemem_ai-0.1.0/synapsemem_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

synapsemem_ai-0.1.0/synapsemem_ai.egg-info/requires.txt

@@ -0,0 +1 @@
+ollama>=0.1.0

synapsemem_ai-0.1.0/synapsemem_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+synapsemem