antaris-memory 0.1.0__tar.gz

antaris_memory-0.1.0/LICENSE

@@ -0,0 +1,24 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Antaris Analytics LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   PATENT NOTICE: The methods implemented in this software are the subject
+   of US Patent Application #63/983,397 (pending). Use of this software
+   under the Apache 2.0 license includes an implied patent license for
+   personal and non-commercial use. Commercial products that implement
+   the patented methods independently (outside of this codebase) require
+   a separate commercial license from Antaris Analytics.

antaris_memory-0.1.0/PKG-INFO

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: antaris-memory
+Version: 0.1.0
+Summary: Human-like memory for AI agents. Patent pending.
+Author-email: Antaris Analytics <moro@antarisanalytics.ai>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/Antaris1337/antaris-memory
+Project-URL: Documentation, https://memory.antarisanalytics.ai
+Project-URL: Repository, https://github.com/Antaris1337/antaris-memory
+Keywords: ai,memory,agents,llm,persistence,recall
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: embeddings
+Requires-Dist: openai>=1.0; extra == "embeddings"
+Provides-Extra: all
+Requires-Dist: openai>=1.0; extra == "all"
+Dynamic: license-file
+
+# 🧠 Antaris Memory
+
+**Human-like memory for AI agents. Patent pending.**
+
+Give your AI agents persistent memory that decays, reinforces, feels, reasons about time, detects its own contradictions, and cleans up after itself. For under $5/year.
+
+[![Patent Pending](https://img.shields.io/badge/Patent-Pending-blue)](https://antarisanalytics.ai)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-green.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-Apache%202.0-orange.svg)](LICENSE)
+
+## The Problem
+
+Every AI agent forgets everything between sessions. GPT, Claude, Gemini — they all start from zero every time. Enterprise memory solutions cost $5,000-$50,000/year and provide basic retrieval at best.
+
+## The Solution
+
+```python
+from antaris_memory import MemorySystem
+
+# Initialize
+mem = MemorySystem("./my-agent-workspace")
+
+# Ingest conversations, notes, anything
+mem.ingest_file("conversation.md", category="tactical")
+mem.ingest_directory("./memory", pattern="*.md", category="tactical")
+
+# Search with decay-weighted relevance
+results = mem.search("what did we decide about pricing?")
+
+# Ask about time
+memories = mem.on_date("2026-02-14")
+story = mem.narrative(topic="patent filing")
+
+# Forget things (GDPR-ready)
+mem.forget(entity="John Doe")
+mem.forget(before_date="2025-01-01")
+
+# Run dream-state consolidation
+report = mem.consolidate()
+
+# Save
+mem.save()
+```
+
+## Features
+
+| Feature | Description | Patent Claim |
+|---------|-------------|-------------|
+| **Memory Decay** | Ebbinghaus-inspired forgetting curves with reinforcement on access | Claim 16 |
+| **Sentiment Tagging** | Auto-detect emotional context (positive, negative, urgent, strategic, financial) | Claim 17 |
+| **Temporal Reasoning** | Query by date, date ranges, build chronological narratives | Claim 22 |
+| **Confidence Scoring** | Track reliability, increase on corroboration | Claim 23 |
+| **Contradiction Detection** | Flag when memories conflict with each other | Claim 23 |
+| **Memory Compression** | Auto-summarize old files, preserve key points | Claim 20 |
+| **Selective Forgetting** | GDPR-ready deletion by topic, entity, or date with audit trail | Claim 21 |
+| **Dream State** | Background consolidation: find duplicates, cluster topics, generate insights | Claim 24 |
+
+## Install
+
+```bash
+pip install antaris-memory
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Antaris1337/antaris-memory.git
+cd antaris-memory
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from antaris_memory import MemorySystem
+
+# Create a memory system
+mem = MemorySystem("./workspace", half_life=7.0)
+
+# Load existing state (if any)
+mem.load()
+
+# Ingest some content
+mem.ingest("Today we decided to use PostgreSQL for the database.", 
+           source="meeting-notes", category="strategic")
+
+mem.ingest("The API costs $500/month which is too expensive.",
+           source="review", category="financial")
+
+# Search
+results = mem.search("database decision")
+for r in results:
+    print(f"[{r.confidence:.1f}] {r.content}")
+
+# Check stats
+print(mem.stats())
+
+# Save state
+mem.save()
+```
+
+## How It Works
+
+### Memory Decay (Ebbinghaus Curves)
+
+Memories naturally fade over time, just like human memory:
+
+```
+Score = Importance × 2^(-age / half_life) + reinforcement
+```
+
+- **Fresh memories** score high
+- **Old unused memories** fade toward zero
+- **Accessed memories** get reinforced — the more you recall something, the stronger it stays
+- Memories below the archive threshold are candidates for compression
+
+### Sentiment Analysis
+
+Every memory is auto-tagged with emotional context:
+
+```python
+entry.sentiment = {"positive": 0.8, "financial": 0.5}
+```
+
+Search by emotion: `mem.search("budget", sentiment_filter="financial")`
+
+### Dream State Consolidation
+
+Run periodically (cron job, background task) to:
+- Find and merge near-duplicate memories
+- Discover topic clusters
+- Detect contradictions
+- Suggest memories for archival
+
+```python
+report = mem.consolidate()
+# Returns: duplicates found, clusters, contradictions, archive suggestions
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│              MemorySystem                    │
+│                                             │
+│  ┌──────────┐ ┌───────────┐ ┌────────────┐ │
+│  │  Decay   │ │ Sentiment │ │  Temporal   │ │
+│  │  Engine  │ │  Tagger   │ │  Engine     │ │
+│  └──────────┘ └───────────┘ └────────────┘ │
+│  ┌──────────┐ ┌───────────┐ ┌────────────┐ │
+│  │Confidence│ │Compression│ │ Forgetting  │ │
+│  │  Engine  │ │  Engine   │ │  Engine     │ │
+│  └──────────┘ └───────────┘ └────────────┘ │
+│  ┌──────────────────────────────────────┐   │
+│  │     Consolidation Engine             │   │
+│  │     (Dream State Processing)         │   │
+│  └──────────────────────────────────────┘   │
+│                                             │
+│  Storage: JSON file (zero dependencies)     │
+└─────────────────────────────────────────────┘
+```
+
+## Configuration
+
+```python
+mem = MemorySystem(
+    workspace="./workspace",    # Where to store metadata
+    half_life=7.0,              # Memory decay half-life in days
+    tag_terms=["custom", "terms"],  # Additional auto-tag keywords
+)
+```
+
+## Zero Dependencies
+
+Antaris Memory uses only Python standard library. No numpy, no torch, no API keys required.
+
+**Optional:** Install `openai` for embedding-based semantic search (coming in v0.2).
+
+## Comparison
+
+| Feature | Antaris Memory | LangChain Memory | Mem0 | Zep |
+|---------|---------------|-----------------|------|-----|
+| Memory decay curves | ✅ | ❌ | ❌ | ❌ |
+| Emotional tagging | ✅ | ❌ | ❌ | ❌ |
+| Temporal reasoning | ✅ | ❌ | ❌ | ❌ |
+| Contradiction detection | ✅ | ❌ | ❌ | ❌ |
+| Selective forgetting | ✅ | ❌ | ❌ | ❌ |
+| Dream state consolidation | ✅ | ❌ | ❌ | ❌ |
+| Zero dependencies | ✅ | ❌ | ❌ | ❌ |
+| Cost per year | <$5 | $500+ | $500+ | $1000+ |
+| Patent protected | ✅ | ❌ | ❌ | ❌ |
+
+## License
+
+Apache 2.0 — free for personal and commercial use.
+
+The underlying technology is protected by US Patent Application #63/983,397 (pending). Commercial products that implement the patented methods require a commercial license from Antaris Analytics.
+
+## Built by
+
+**Antaris Analytics** — AI memory intelligence  
+📧 moro@antarisanalytics.ai  
+🌐 [antarisanalytics.ai](https://antarisanalytics.ai)
+
+---
+
+*"We gave AI agents human-like memory for $5/year."*

antaris_memory-0.1.0/README.md

@@ -0,0 +1,207 @@
+# 🧠 Antaris Memory
+
+**Human-like memory for AI agents. Patent pending.**
+
+Give your AI agents persistent memory that decays, reinforces, feels, reasons about time, detects its own contradictions, and cleans up after itself. For under $5/year.
+
+[![Patent Pending](https://img.shields.io/badge/Patent-Pending-blue)](https://antarisanalytics.ai)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-green.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-Apache%202.0-orange.svg)](LICENSE)
+
+## The Problem
+
+Every AI agent forgets everything between sessions. GPT, Claude, Gemini — they all start from zero every time. Enterprise memory solutions cost $5,000-$50,000/year and provide basic retrieval at best.
+
+## The Solution
+
+```python
+from antaris_memory import MemorySystem
+
+# Initialize
+mem = MemorySystem("./my-agent-workspace")
+
+# Ingest conversations, notes, anything
+mem.ingest_file("conversation.md", category="tactical")
+mem.ingest_directory("./memory", pattern="*.md", category="tactical")
+
+# Search with decay-weighted relevance
+results = mem.search("what did we decide about pricing?")
+
+# Ask about time
+memories = mem.on_date("2026-02-14")
+story = mem.narrative(topic="patent filing")
+
+# Forget things (GDPR-ready)
+mem.forget(entity="John Doe")
+mem.forget(before_date="2025-01-01")
+
+# Run dream-state consolidation
+report = mem.consolidate()
+
+# Save
+mem.save()
+```
+
+## Features
+
+| Feature | Description | Patent Claim |
+|---------|-------------|-------------|
+| **Memory Decay** | Ebbinghaus-inspired forgetting curves with reinforcement on access | Claim 16 |
+| **Sentiment Tagging** | Auto-detect emotional context (positive, negative, urgent, strategic, financial) | Claim 17 |
+| **Temporal Reasoning** | Query by date, date ranges, build chronological narratives | Claim 22 |
+| **Confidence Scoring** | Track reliability, increase on corroboration | Claim 23 |
+| **Contradiction Detection** | Flag when memories conflict with each other | Claim 23 |
+| **Memory Compression** | Auto-summarize old files, preserve key points | Claim 20 |
+| **Selective Forgetting** | GDPR-ready deletion by topic, entity, or date with audit trail | Claim 21 |
+| **Dream State** | Background consolidation: find duplicates, cluster topics, generate insights | Claim 24 |
+
+## Install
+
+```bash
+pip install antaris-memory
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Antaris1337/antaris-memory.git
+cd antaris-memory
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from antaris_memory import MemorySystem
+
+# Create a memory system
+mem = MemorySystem("./workspace", half_life=7.0)
+
+# Load existing state (if any)
+mem.load()
+
+# Ingest some content
+mem.ingest("Today we decided to use PostgreSQL for the database.", 
+           source="meeting-notes", category="strategic")
+
+mem.ingest("The API costs $500/month which is too expensive.",
+           source="review", category="financial")
+
+# Search
+results = mem.search("database decision")
+for r in results:
+    print(f"[{r.confidence:.1f}] {r.content}")
+
+# Check stats
+print(mem.stats())
+
+# Save state
+mem.save()
+```
+
+## How It Works
+
+### Memory Decay (Ebbinghaus Curves)
+
+Memories naturally fade over time, just like human memory:
+
+```
+Score = Importance × 2^(-age / half_life) + reinforcement
+```
+
+- **Fresh memories** score high
+- **Old unused memories** fade toward zero
+- **Accessed memories** get reinforced — the more you recall something, the stronger it stays
+- Memories below the archive threshold are candidates for compression
+
+### Sentiment Analysis
+
+Every memory is auto-tagged with emotional context:
+
+```python
+entry.sentiment = {"positive": 0.8, "financial": 0.5}
+```
+
+Search by emotion: `mem.search("budget", sentiment_filter="financial")`
+
+### Dream State Consolidation
+
+Run periodically (cron job, background task) to:
+- Find and merge near-duplicate memories
+- Discover topic clusters
+- Detect contradictions
+- Suggest memories for archival
+
+```python
+report = mem.consolidate()
+# Returns: duplicates found, clusters, contradictions, archive suggestions
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│              MemorySystem                    │
+│                                             │
+│  ┌──────────┐ ┌───────────┐ ┌────────────┐ │
+│  │  Decay   │ │ Sentiment │ │  Temporal   │ │
+│  │  Engine  │ │  Tagger   │ │  Engine     │ │
+│  └──────────┘ └───────────┘ └────────────┘ │
+│  ┌──────────┐ ┌───────────┐ ┌────────────┐ │
+│  │Confidence│ │Compression│ │ Forgetting  │ │
+│  │  Engine  │ │  Engine   │ │  Engine     │ │
+│  └──────────┘ └───────────┘ └────────────┘ │
+│  ┌──────────────────────────────────────┐   │
+│  │     Consolidation Engine             │   │
+│  │     (Dream State Processing)         │   │
+│  └──────────────────────────────────────┘   │
+│                                             │
+│  Storage: JSON file (zero dependencies)     │
+└─────────────────────────────────────────────┘
+```
+
+## Configuration
+
+```python
+mem = MemorySystem(
+    workspace="./workspace",    # Where to store metadata
+    half_life=7.0,              # Memory decay half-life in days
+    tag_terms=["custom", "terms"],  # Additional auto-tag keywords
+)
+```
+
+## Zero Dependencies
+
+Antaris Memory uses only Python standard library. No numpy, no torch, no API keys required.
+
+**Optional:** Install `openai` for embedding-based semantic search (coming in v0.2).
+
+## Comparison
+
+| Feature | Antaris Memory | LangChain Memory | Mem0 | Zep |
+|---------|---------------|-----------------|------|-----|
+| Memory decay curves | ✅ | ❌ | ❌ | ❌ |
+| Emotional tagging | ✅ | ❌ | ❌ | ❌ |
+| Temporal reasoning | ✅ | ❌ | ❌ | ❌ |
+| Contradiction detection | ✅ | ❌ | ❌ | ❌ |
+| Selective forgetting | ✅ | ❌ | ❌ | ❌ |
+| Dream state consolidation | ✅ | ❌ | ❌ | ❌ |
+| Zero dependencies | ✅ | ❌ | ❌ | ❌ |
+| Cost per year | <$5 | $500+ | $500+ | $1000+ |
+| Patent protected | ✅ | ❌ | ❌ | ❌ |
+
+## License
+
+Apache 2.0 — free for personal and commercial use.
+
+The underlying technology is protected by US Patent Application #63/983,397 (pending). Commercial products that implement the patented methods require a commercial license from Antaris Analytics.
+
+## Built by
+
+**Antaris Analytics** — AI memory intelligence  
+📧 moro@antarisanalytics.ai  
+🌐 [antarisanalytics.ai](https://antarisanalytics.ai)
+
+---
+
+*"We gave AI agents human-like memory for $5/year."*

antaris_memory-0.1.0/antaris_memory/__init__.py

@@ -0,0 +1,41 @@
+"""
+Antaris Memory — Human-like memory for AI agents.
+Patent Pending: US Application #63/983,397
+
+Give your AI agents persistent memory that decays, reinforces,
+feels, reasons about time, and cleans up after itself.
+For under $5/year.
+
+Usage:
+    from antaris_memory import MemorySystem
+
+    mem = MemorySystem("/path/to/workspace")
+    mem.ingest_file("conversation.md", category="tactical")
+    results = mem.search("what did we decide about pricing?")
+    mem.save()
+"""
+
+__version__ = "0.1.0"
+__patent__ = "US Application #63/983,397 (Patent Pending)"
+
+from antaris_memory.core import MemorySystem
+from antaris_memory.entry import MemoryEntry
+from antaris_memory.decay import DecayEngine
+from antaris_memory.sentiment import SentimentTagger
+from antaris_memory.temporal import TemporalEngine
+from antaris_memory.confidence import ConfidenceEngine
+from antaris_memory.compression import CompressionEngine
+from antaris_memory.forgetting import ForgettingEngine
+from antaris_memory.consolidation import ConsolidationEngine
+
+__all__ = [
+    "MemorySystem",
+    "MemoryEntry",
+    "DecayEngine",
+    "SentimentTagger",
+    "TemporalEngine",
+    "ConfidenceEngine",
+    "CompressionEngine",
+    "ForgettingEngine",
+    "ConsolidationEngine",
+]

antaris_memory-0.1.0/antaris_memory/compression.py

@@ -0,0 +1,65 @@
+"""Claim 20: Memory compression & summarization."""
+
+import re
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List
+
+
+class CompressionEngine:
+    """Compress old memories into condensed summaries."""
+
+    @staticmethod
+    def compress_file(file_path: str) -> Dict:
+        """Read a memory file and produce a compressed summary."""
+        try:
+            content = Path(file_path).read_text()
+        except (FileNotFoundError, UnicodeDecodeError):
+            return {"error": f"Cannot read: {file_path}"}
+
+        lines = content.strip().split("\n")
+        headers = [l for l in lines if l.startswith("#")]
+        bullets = [l.strip() for l in lines if l.strip().startswith("- ")]
+        markers = ["✅", "🎯", "💰", "🚀", "Decision:", "Key:", "Result:"]
+        key_lines = [
+            l.strip() for l in lines
+            if any(m in l for m in markers)
+        ]
+
+        seen = set()
+        unique = []
+        for b in bullets + key_lines:
+            norm = b.lower().strip("- ").strip()
+            if norm not in seen and len(norm) > 10:
+                seen.add(norm)
+                unique.append(b)
+
+        return {
+            "source": file_path,
+            "original_lines": len(lines),
+            "compressed_lines": len(headers) + len(unique),
+            "compression_ratio": round(
+                1 - (len(headers) + len(unique)) / max(len(lines), 1), 2
+            ),
+            "headers": headers,
+            "key_points": unique[:30],
+            "compressed_at": datetime.now().isoformat(),
+        }
+
+    @staticmethod
+    def compress_old_files(memory_dir: str, days_old: int = 7) -> List[Dict]:
+        """Compress daily memory files older than *days_old*."""
+        path = Path(memory_dir)
+        if not path.exists():
+            return []
+
+        cutoff = datetime.now() - timedelta(days=days_old)
+        results = []
+        for f in sorted(path.glob("*.md")):
+            match = re.search(r"(\d{4}-\d{2}-\d{2})", f.name)
+            if not match:
+                continue
+            file_date = datetime.strptime(match.group(1), "%Y-%m-%d")
+            if file_date < cutoff:
+                results.append(CompressionEngine.compress_file(str(f)))
+        return results

antaris_memory-0.1.0/antaris_memory/confidence.py

@@ -0,0 +1,45 @@
+"""Claim 23: Confidence scoring & contradiction detection."""
+
+from typing import List, Tuple
+from .entry import MemoryEntry
+
+NEGATION_PAIRS = [
+    ("working", "broken"), ("stable", "crashed"), ("complete", "incomplete"),
+    ("fixed", "broken"), ("success", "failed"), ("approved", "rejected"),
+    ("cheap", "expensive"), ("fast", "slow"), ("available", "unavailable"),
+    ("secure", "vulnerable"), ("online", "offline"), ("enabled", "disabled"),
+]
+
+
+class ConfidenceEngine:
+    """Track memory reliability and detect contradictions."""
+
+    @staticmethod
+    def corroborate(entry: MemoryEntry, boost: float = 0.1) -> None:
+        """Increase confidence when info is confirmed by another source."""
+        entry.confidence = min(entry.confidence + boost, 1.0)
+
+    @staticmethod
+    def find_contradictions(
+        memories: List[MemoryEntry],
+    ) -> List[Tuple[MemoryEntry, MemoryEntry, str]]:
+        """Detect potential contradictions via opposing keyword pairs on shared topics."""
+        contradictions = []
+        for i, m1 in enumerate(memories):
+            m1_lower = m1.content.lower()
+            for m2 in memories[i + 1:]:
+                if m1.source == m2.source and abs(m1.line - m2.line) < 5:
+                    continue
+                m2_lower = m2.content.lower()
+                for pos, neg in NEGATION_PAIRS:
+                    if (pos in m1_lower and neg in m2_lower) or \
+                       (neg in m1_lower and pos in m2_lower):
+                        shared = set(m1.tags) & set(m2.tags)
+                        if shared:
+                            reason = (
+                                f"Conflicting states ({pos}/{neg}) "
+                                f"on topic: {', '.join(shared)}"
+                            )
+                            contradictions.append((m1, m2, reason))
+                            break
+        return contradictions