kore-memory 0.2.0__tar.gz

kore_memory-0.2.0/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environment
+.venv/
+venv/
+env/
+
+# Data & secrets — NEVER commit
+data/
+logs/
+*.db
+*.db-shm
+*.db-wal
+.api_key
+*.key
+*.secret
+.env
+.env.*
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# OS
+.DS_Store
+Thumbs.db

kore_memory-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juan Auriti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kore_memory-0.2.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: kore-memory
+Version: 0.2.0
+Summary: The memory layer that thinks like a human: remembers what matters, forgets what doesn't, and never calls home.
+Project-URL: Homepage, https://github.com/juanauriti/kore-memory
+Project-URL: Repository, https://github.com/juanauriti/kore-memory
+Project-URL: Issues, https://github.com/juanauriti/kore-memory/issues
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,embeddings,llm,memory,rag,semantic-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Provides-Extra: semantic
+Requires-Dist: sentence-transformers>=3.0.0; extra == 'semantic'
+Description-Content-Type: text/markdown
+
+# Kore Memory
+
+> **The memory layer that thinks like a human: remembers what matters, forgets what doesn't, and never calls home.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://python.org)
+[![Zero Cloud Dependencies](https://img.shields.io/badge/cloud-zero-green.svg)]()
+
+---
+
+## Why Kore?
+
+Every AI agent memory tool out there has the same problem: they remember everything forever, require cloud APIs, or need an LLM just to decide what's worth storing.
+
+**Kore is different.**
+
+| Feature | Kore | Mem0 | Letta | Memori |
+|---|---|---|---|---|
+| Runs fully offline | ✅ | ❌ | ❌ | ❌ |
+| No LLM required | ✅ | ❌ | ❌ | ✅ |
+| Memory Decay (Ebbinghaus) | ✅ | ❌ | ❌ | ❌ |
+| Auto-importance scoring | ✅ local | ✅ via LLM | ❌ | ❌ |
+| Memory Compression | ✅ | ❌ | ❌ | ❌ |
+| Semantic search (50+ langs) | ✅ local | ✅ via API | ✅ | ✅ |
+| Timeline API | ✅ | ❌ | ❌ | ❌ |
+| Access reinforcement | ✅ | ❌ | ❌ | ❌ |
+| Install in 2 minutes | ✅ | ❌ | ❌ | ❌ |
+
+---
+
+## How It Works
+
+Kore models memory the way the human brain does:
+
+1. **Save** — store a memory with optional category and importance
+2. **Auto-score** — Kore calculates importance locally using content analysis (no API calls)
+3. **Decay** — memories fade over time using the [Ebbinghaus forgetting curve](https://en.wikipedia.org/wiki/Forgetting_curve)
+4. **Reinforce** — retrieving a memory resets its clock and boosts its score
+5. **Compress** — similar memories are automatically merged to keep the DB lean
+6. **Search** — semantic search in any language, filtered by relevance and freshness
+
+---
+
+## Quickstart
+
+```bash
+pip install kore-memory
+pip install kore-memory[semantic]   # + multilingual embeddings (50+ languages)
+
+kore                                # starts server on http://localhost:8765
+```
+
+### Save a memory
+
+```bash
+curl -X POST http://localhost:8765/save \
+  -H "Content-Type: application/json" \
+  -d '{"content": "User prefers concise responses", "category": "preference"}'
+# → {"id": 1, "importance": 4, "message": "Memory saved"}
+# importance was auto-scored: "preference" category + keyword "prefers" → 4
+```
+
+### Search (any language)
+
+```bash
+# English query finds Italian content, French content, etc.
+curl "http://localhost:8765/search?q=user+preferences&limit=5"
+```
+
+### Run decay pass (call daily via cron)
+
+```bash
+curl -X POST http://localhost:8765/decay/run
+# → {"updated": 42, "message": "Decay pass complete"}
+```
+
+### Compress similar memories
+
+```bash
+curl -X POST http://localhost:8765/compress
+# → {"clusters_found": 3, "memories_merged": 7, "new_records_created": 3}
+```
+
+### Timeline: what did I know about X over time?
+
+```bash
+curl "http://localhost:8765/timeline?subject=project+alpha"
+```
+
+---
+
+## Memory Decay
+
+Kore uses the **Ebbinghaus forgetting curve** to assign each memory a `decay_score` between 0.0 and 1.0:
+
+```
+decay = e^(-t * ln(2) / half_life)
+```
+
+Where:
+- `t` = days since last access
+- `half_life` = base days before 50% decay, adjusted by importance level
+
+| Importance | Half-life | Meaning |
+|---|---|---|
+| 1 (low) | 7 days | Casual notes |
+| 2 (normal) | 14 days | General context |
+| 3 (important) | 30 days | Project info |
+| 4 (high) | 90 days | Critical decisions |
+| 5 (critical) | 365 days | Passwords, rules, never forget |
+
+Every time a memory is retrieved, its `access_count` increases and its half-life is extended by 15% — just like spaced repetition in human learning.
+
+---
+
+## Auto-Importance Scoring
+
+When you save a memory without an explicit importance level, Kore scores it automatically:
+
+- **Category baseline** — `preference` starts at 4, `finance` at 3, `general` at 1
+- **Keyword signals** — words like `password`, `token`, `urgente` → importance 5
+- **Content length** — detailed content gets a small boost
+
+Zero LLM calls. Zero API costs.
+
+---
+
+## API Reference
+
+| Method | Endpoint | Description |
+|---|---|---|
+| `POST` | `/save` | Save a memory |
+| `GET` | `/search` | Semantic search (any language) |
+| `GET` | `/timeline` | Chronological history for a subject |
+| `DELETE` | `/memories/{id}` | Delete a memory |
+| `POST` | `/decay/run` | Update all decay scores |
+| `POST` | `/compress` | Merge similar memories |
+| `GET` | `/health` | Health check + capabilities |
+
+Full interactive docs: `http://localhost:8765/docs`
+
+---
+
+## Categories
+
+`general` · `project` · `trading` · `finance` · `person` · `preference` · `task` · `decision`
+
+---
+
+## Requirements
+
+- Python 3.11+
+- SQLite (built into Python)
+- Optional: `sentence-transformers` for semantic search
+
+No PostgreSQL. No Redis. No Docker. No API keys.
+
+---
+
+## License
+
+MIT — use it, fork it, build on it.
+
+---
+
+*Built with ❤️ for AI agents that deserve better memory.*

kore_memory-0.2.0/README.md

@@ -0,0 +1,166 @@
+# Kore Memory
+
+> **The memory layer that thinks like a human: remembers what matters, forgets what doesn't, and never calls home.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://python.org)
+[![Zero Cloud Dependencies](https://img.shields.io/badge/cloud-zero-green.svg)]()
+
+---
+
+## Why Kore?
+
+Every AI agent memory tool out there has the same problem: they remember everything forever, require cloud APIs, or need an LLM just to decide what's worth storing.
+
+**Kore is different.**
+
+| Feature | Kore | Mem0 | Letta | Memori |
+|---|---|---|---|---|
+| Runs fully offline | ✅ | ❌ | ❌ | ❌ |
+| No LLM required | ✅ | ❌ | ❌ | ✅ |
+| Memory Decay (Ebbinghaus) | ✅ | ❌ | ❌ | ❌ |
+| Auto-importance scoring | ✅ local | ✅ via LLM | ❌ | ❌ |
+| Memory Compression | ✅ | ❌ | ❌ | ❌ |
+| Semantic search (50+ langs) | ✅ local | ✅ via API | ✅ | ✅ |
+| Timeline API | ✅ | ❌ | ❌ | ❌ |
+| Access reinforcement | ✅ | ❌ | ❌ | ❌ |
+| Install in 2 minutes | ✅ | ❌ | ❌ | ❌ |
+
+---
+
+## How It Works
+
+Kore models memory the way the human brain does:
+
+1. **Save** — store a memory with optional category and importance
+2. **Auto-score** — Kore calculates importance locally using content analysis (no API calls)
+3. **Decay** — memories fade over time using the [Ebbinghaus forgetting curve](https://en.wikipedia.org/wiki/Forgetting_curve)
+4. **Reinforce** — retrieving a memory resets its clock and boosts its score
+5. **Compress** — similar memories are automatically merged to keep the DB lean
+6. **Search** — semantic search in any language, filtered by relevance and freshness
+
+---
+
+## Quickstart
+
+```bash
+pip install kore-memory
+pip install kore-memory[semantic]   # + multilingual embeddings (50+ languages)
+
+kore                                # starts server on http://localhost:8765
+```
+
+### Save a memory
+
+```bash
+curl -X POST http://localhost:8765/save \
+  -H "Content-Type: application/json" \
+  -d '{"content": "User prefers concise responses", "category": "preference"}'
+# → {"id": 1, "importance": 4, "message": "Memory saved"}
+# importance was auto-scored: "preference" category + keyword "prefers" → 4
+```
+
+### Search (any language)
+
+```bash
+# English query finds Italian content, French content, etc.
+curl "http://localhost:8765/search?q=user+preferences&limit=5"
+```
+
+### Run decay pass (call daily via cron)
+
+```bash
+curl -X POST http://localhost:8765/decay/run
+# → {"updated": 42, "message": "Decay pass complete"}
+```
+
+### Compress similar memories
+
+```bash
+curl -X POST http://localhost:8765/compress
+# → {"clusters_found": 3, "memories_merged": 7, "new_records_created": 3}
+```
+
+### Timeline: what did I know about X over time?
+
+```bash
+curl "http://localhost:8765/timeline?subject=project+alpha"
+```
+
+---
+
+## Memory Decay
+
+Kore uses the **Ebbinghaus forgetting curve** to assign each memory a `decay_score` between 0.0 and 1.0:
+
+```
+decay = e^(-t * ln(2) / half_life)
+```
+
+Where:
+- `t` = days since last access
+- `half_life` = base days before 50% decay, adjusted by importance level
+
+| Importance | Half-life | Meaning |
+|---|---|---|
+| 1 (low) | 7 days | Casual notes |
+| 2 (normal) | 14 days | General context |
+| 3 (important) | 30 days | Project info |
+| 4 (high) | 90 days | Critical decisions |
+| 5 (critical) | 365 days | Passwords, rules, never forget |
+
+Every time a memory is retrieved, its `access_count` increases and its half-life is extended by 15% — just like spaced repetition in human learning.
+
+---
+
+## Auto-Importance Scoring
+
+When you save a memory without an explicit importance level, Kore scores it automatically:
+
+- **Category baseline** — `preference` starts at 4, `finance` at 3, `general` at 1
+- **Keyword signals** — words like `password`, `token`, `urgente` → importance 5
+- **Content length** — detailed content gets a small boost
+
+Zero LLM calls. Zero API costs.
+
+---
+
+## API Reference
+
+| Method | Endpoint | Description |
+|---|---|---|
+| `POST` | `/save` | Save a memory |
+| `GET` | `/search` | Semantic search (any language) |
+| `GET` | `/timeline` | Chronological history for a subject |
+| `DELETE` | `/memories/{id}` | Delete a memory |
+| `POST` | `/decay/run` | Update all decay scores |
+| `POST` | `/compress` | Merge similar memories |
+| `GET` | `/health` | Health check + capabilities |
+
+Full interactive docs: `http://localhost:8765/docs`
+
+---
+
+## Categories
+
+`general` · `project` · `trading` · `finance` · `person` · `preference` · `task` · `decision`
+
+---
+
+## Requirements
+
+- Python 3.11+
+- SQLite (built into Python)
+- Optional: `sentence-transformers` for semantic search
+
+No PostgreSQL. No Redis. No Docker. No API keys.
+
+---
+
+## License
+
+MIT — use it, fork it, build on it.
+
+---
+
+*Built with ❤️ for AI agents that deserve better memory.*

kore_memory-0.2.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "kore-memory"
+version = "0.2.0"
+description = "The memory layer that thinks like a human: remembers what matters, forgets what doesn't, and never calls home."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+keywords = ["ai", "memory", "agents", "llm", "embeddings", "semantic-search", "rag"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.30.0",
+    "pydantic>=2.7.0",
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+semantic = [
+    "sentence-transformers>=3.0.0",
+]
+dev = [
+    "pytest>=8.0.0",
+    "httpx>=0.27.0",
+    "pytest-asyncio>=0.23.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/juanauriti/kore-memory"
+Repository = "https://github.com/juanauriti/kore-memory"
+Issues = "https://github.com/juanauriti/kore-memory/issues"
+
+[project.scripts]
+kore = "kore.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

kore_memory-0.2.0/requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+pydantic>=2.7.0
+sentence-transformers>=3.0.0
+httpx>=0.27.0

kore_memory-0.2.0/scripts/import_memory.py

@@ -0,0 +1,135 @@
+"""
+Kore — import_memory.py
+Popola il DB Kore leggendo MEMORY.md e suddividendo per sezioni.
+Esegui una volta sola dopo l'installazione.
+"""
+
+import re
+import sys
+import json
+from pathlib import Path
+
+import httpx
+
+MEMORY_PATH = Path(__file__).parent.parent.parent / "MEMORY.md"
+KORE_URL = "http://localhost:8765"
+
+SECTION_CATEGORY_MAP = {
+    "finanz": "finance",
+    "kore": "project",
+    "progetti": "project",
+    "clawdwork": "task",
+    "freelance": "person",
+    "crypto": "trading",
+    "regole": "preference",
+    "ottimizzaz": "preference",
+    "calcfast": "project",
+    "amazon": "project",
+    "agencypilot": "project",
+    "priorità": "task",
+}
+
+IMPORTANCE_MAP = {
+    "finance": 4,
+    "trading": 4,
+    "project": 3,
+    "task": 3,
+    "preference": 5,
+    "person": 2,
+    "decision": 4,
+    "general": 2,
+}
+
+
+def detect_category(section_title: str) -> str:
+    title_lower = section_title.lower()
+    for keyword, category in SECTION_CATEGORY_MAP.items():
+        if keyword in title_lower:
+            return category
+    return "general"
+
+
+def parse_memory_md(path: Path) -> list[dict]:
+    """Split MEMORY.md into chunks by H2 section, return list of records."""
+    text = path.read_text(encoding="utf-8")
+    sections = re.split(r"\n(?=## )", text)
+
+    records = []
+    for section in sections:
+        lines = section.strip().splitlines()
+        if not lines:
+            continue
+
+        title_line = lines[0].lstrip("#").strip()
+        body_lines = [l for l in lines[1:] if l.strip() and not l.startswith("---")]
+
+        if not body_lines:
+            continue
+
+        category = detect_category(title_line)
+        importance = IMPORTANCE_MAP.get(category, 2)
+
+        # Split long sections into sub-chunks by bullet points
+        chunks = chunk_section(title_line, body_lines)
+        for chunk in chunks:
+            records.append({
+                "content": chunk,
+                "category": category,
+                "importance": importance,
+            })
+
+    return records
+
+
+def chunk_section(title: str, lines: list[str]) -> list[str]:
+    """
+    Group bullet lines into chunks of max 3 items, prefixed with section title.
+    Avoids saving single massive blobs.
+    """
+    bullets = [l.strip().lstrip("-").lstrip("*").strip() for l in lines if l.strip()]
+    bullets = [b for b in bullets if len(b) > 10]
+
+    if not bullets:
+        return []
+
+    chunks = []
+    for i in range(0, len(bullets), 3):
+        group = bullets[i:i+3]
+        chunk = f"[{title}] " + " | ".join(group)
+        if len(chunk) > 4000:
+            chunk = chunk[:3997] + "..."
+        chunks.append(chunk)
+
+    return chunks
+
+
+def save_record(record: dict) -> int | None:
+    try:
+        resp = httpx.post(f"{KORE_URL}/save", json=record, timeout=5)
+        if resp.status_code == 201:
+            return resp.json()["id"]
+        else:
+            print(f"  ⚠️  {resp.status_code}: {resp.text[:80]}")
+            return None
+    except Exception as e:
+        print(f"  ❌ Errore: {e}")
+        return None
+
+
+def main():
+    print(f"📂 Lettura {MEMORY_PATH}...")
+    records = parse_memory_md(MEMORY_PATH)
+    print(f"📝 Trovati {len(records)} chunk da importare\n")
+
+    saved = 0
+    for rec in records:
+        record_id = save_record(rec)
+        if record_id:
+            print(f"  ✅ #{record_id} [{rec['category']}] ★{rec['importance']} — {rec['content'][:60]}...")
+            saved += 1
+
+    print(f"\n🎉 Importati {saved}/{len(records)} record in Kore")
+
+
+if __name__ == "__main__":
+    main()

kore_memory-0.2.0/src/__init__.py

@@ -0,0 +1 @@
+# Kore package