kausamemory 2.1.0__tar.gz

kausamemory-2.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

kausamemory-2.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: kausamemory
+Version: 2.1.0
+Summary: Persistent encrypted memory for AI agents. Knowledge graph, vector search, decision tracking, encrypted IPFS backup.
+Author-email: KausaLayer <kausalayer@proton.me>
+License: Apache-2.0
+Project-URL: Homepage, https://kausalayer.com
+Project-URL: Repository, https://github.com/fasqua/kausamemory-v2
+Keywords: ai,agent,memory,mcp,knowledge-graph,solana,encryption,ipfs
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: fastembed>=0.4.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: cryptography>=43.0.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30.0; extra == "anthropic"
+Dynamic: license-file

kausamemory-2.1.0/README.md

@@ -0,0 +1,304 @@
+# KausaMemory v2
+
+Persistent encrypted memory for AI agents. Knowledge graph, vector search, decision tracking, user profiling, and encrypted IPFS backup — in a single SQLite file.
+
+Built by [KausaLayer](https://kausalayer.com) — privacy infrastructure for Solana.
+
+![Architecture](./kausamemory-v2-architecture.png)
+
+## Why KausaMemory
+
+Your AI agent forgets everything between sessions. KausaMemory fixes that.
+
+Every conversation is automatically broken down into entities, relationships, decisions, and user traits — stored in a local knowledge graph, encrypted with your passphrase, and backed up to IPFS. Switch devices, delete your database, reinstall — your agent's memory comes back.
+
+No cloud vendor holds your data. No one can read it. Just you and your passphrase.
+
+## Features
+
+**Knowledge Graph** — entities with typed properties, relationships with temporal validity, recursive CTE traversal, upsert with dedup, contradiction detection against existing entities
+
+**Decision Tracking** — decision ledger with reason and topic, supersede chain when decisions change, active/inactive filtering
+
+**User Profiling** — auto-extracted from conversations across 5 categories (identity, preferences, expertise, workflow, personality) with confidence scoring and boost-on-confirm
+
+**Vector Search** — numpy vectorized batch cosine similarity, pre-normalized matrix cache, lazy rebuild, configurable min_similarity threshold (default 0.3)
+
+**Full-Text Search** — 4 FTS5 virtual tables (episodes, entities, decisions, user_profile) with sanitized queries and LIKE fallback
+
+**Tiered Retrieval** — brief (~100 tokens, top 3), summary (~500 tokens, top 5), or full (unlimited, top 10) per query
+
+**4-Strategy Classification** — temporal (time keywords), reasoning (why/because), summary (everything/overview), hybrid (default: vector + graph + FTS)
+
+**Multi-Agent Namespaces** — each namespace gets its own SQLite database, optional cross-agent shared read (read-only)
+
+**Encrypted IPFS Backup** — AES-256-GCM with passphrase-derived key, 12-byte random nonce, Pinata IPFS pinning, CID persisted to local file before unpinning old snapshot
+
+**Safety Checks** — refuses to sync empty databases (prevents overwriting good IPFS snapshots), auto-sync every 5 stores, background sync loop every 120s
+
+## Current Status
+
+KausaMemory v2 is functional and tested with Hermes Agent. It is not yet published on PyPI. To use it, clone this repo and install in editable mode.
+
+## Installation
+
+```bash
+git clone https://github.com/fasqua/kausamemory-v2.git
+cd kausamemory-v2
+pip install -e .
+```
+
+Required environment variables:
+
+```bash
+export MEMORY_PASSPHRASE="your-secret-passphrase"
+export PINATA_API_KEY="your-pinata-key"
+```
+
+Optional (enables LLM extraction of entities, decisions, traits):
+
+```bash
+export LLM_API_KEY="your-api-key"
+export LLM_PROVIDER="openrouter"    # or "openai" or "anthropic"
+export LLM_MODEL="anthropic/claude-sonnet-4"
+```
+
+## Usage
+
+### As MCP Server
+
+The MCP server provides 6 tools to any compatible client (Claude Desktop, Cursor, VS Code, Cline).
+
+Add to your MCP client config:
+
+```json
+{
+  "kausamemory": {
+    "command": "kausamemory-mcp",
+    "env": {
+      "MEMORY_PASSPHRASE": "your-secret-passphrase",
+      "PINATA_API_KEY": "your-pinata-key"
+    }
+  }
+}
+```
+
+**MCP Tools:**
+
+| Tool | Description |
+|------|-------------|
+| `memory_retrieve` | Retrieve context before responding. Supports depth: brief, summary, full |
+| `memory_store` | Store conversation with auto-extraction of entities, decisions, traits |
+| `memory_search` | Search by type: all (semantic), facts (graph), timeline (episodes), decisions, text (FTS5), profile |
+| `memory_forget` | Remove entities, decisions, or profile entries by name/topic/key |
+| `memory_status` | Memory health: entity count, relationships, episodes, decisions, embeddings, profile entries |
+| `memory_sync` | Force encrypted backup to IPFS |
+
+### As Hermes Agent Plugin
+
+KausaMemory integrates as a native Hermes memory provider with full ABC implementation. The plugin auto-prefetches context before each turn, auto-stores after each turn, injects memory stats into the system prompt, and syncs to IPFS on session end.
+
+```yaml
+# ~/.hermes/config.yaml
+memory:
+  provider: kausamemory
+```
+
+```bash
+# ~/.hermes/.env
+MEMORY_PASSPHRASE=your-secret-passphrase
+PINATA_API_KEY=your-pinata-key
+LLM_API_KEY=your-llm-key
+LLM_PROVIDER=openrouter
+LLM_MODEL=anthropic/claude-sonnet-4
+```
+
+The Hermes plugin exposes 7 tools (the 6 MCP tools plus `kausamemory_reconnect` for refreshing the DB connection after external restores).
+
+### As Python Library
+
+```python
+import asyncio
+from kausamemory.engine.core import MemoryEngine
+
+# Initialize — all config from environment variables
+engine = MemoryEngine(namespace="my-agent")
+
+# Store a conversation (async — triggers LLM extraction if LLM_API_KEY set)
+result = asyncio.run(engine.store(
+    "I prefer using Rust for backend development",
+    "Noted, Rust is great for performance-critical systems."
+))
+# Returns: {'stored': True, 'entities': 2, 'relationships': 1, 'decisions': 0, 'traits': 1}
+# Without LLM_API_KEY: {'stored': True, 'mode': 'embedding_only'}
+
+# Retrieve context (sync — returns formatted string)
+context = engine.retrieve("What language do I prefer?", depth="summary")
+
+# Search knowledge graph
+entities = engine.search_entities(name="Rust")         # returns list[dict]
+decisions = engine.search_decisions("backend")          # returns list[dict]
+episodes = engine.search_text("Rust")                   # returns list[dict]
+similar = engine.search_similar("programming language") # returns list[dict]
+
+# Generic search (returns formatted string)
+result = engine.search("Rust", type="facts", limit=5)
+
+# User profile
+engine.set_profile("language", "Rust", "expertise", 0.9)
+profile = engine.get_profile("expertise")   # returns list[dict]
+all_profile = engine.get_profile()           # all entries
+
+# Forget
+engine.forget_entity("SomeEntity")     # returns int (count removed)
+engine.forget_decision("old-topic")    # returns int
+engine.forget_profile("old-key")       # returns bool
+
+# Status (sync)
+stats = engine.status()
+# Returns: {'namespace': '...', 'entities': 142, 'relationships': 87, ...}
+
+# Force sync to IPFS (async)
+result = asyncio.run(engine.force_sync())
+# Returns: {'success': True, 'cid': 'Qm...'}
+
+# Startup — load from IPFS if snapshot exists (async)
+asyncio.run(engine.startup())
+```
+
+## Architecture
+
+```
+kausamemory/
+├── config.py              env-based config (passphrase, API keys, model, data dir)
+├── stores/
+│   ├── database.py        SQLite + 6 tables + 4 FTS5 + threading.Lock + WAL
+│   │                      + restore_from_bytes (state-machine SQL parser)
+│   │                      + reconnect + export_bytes (iterdump)
+│   ├── graph.py           entities + typed relationships + recursive CTE traversal
+│   │                      + temporal validity (valid_from/valid_to) + upsert
+│   ├── episodes.py        conversation timeline + FTS5 search + sanitized queries
+│   │                      + LIKE fallback + timerange/recent queries
+│   ├── decisions.py       decision ledger + supersede chain + topic search
+│   ├── vectors.py         numpy vectorized batch search + pre-normalized matrix
+│   │                      + lazy cache + min_similarity threshold
+│   └── profile.py         5 categories (identity/preferences/expertise/workflow/personality)
+│                           + confidence scoring + boost_on_confirm + to_prompt()
+├── engine/
+│   ├── core.py            MemoryEngine — 15 public methods + auto-sync + safety check
+│   ├── classifier.py      keyword-based 4-strategy classification (English)
+│   ├── retriever.py       4 retrieval strategies × 3 depth levels
+│   │                      + profile injection + shared namespace read
+│   └── extractor.py       LLM prompt → entities + relationships + decisions
+│                           + user_traits + contradiction detection
+├── providers/
+│   ├── embedder.py        FastEmbed BAAI/bge-large-en-v1.5 (1024d, runs locally)
+│   └── llm.py             OpenRouter / OpenAI / Anthropic + _extract_json fallback
+├── crypto/
+│   ├── encryption.py      AES-256-GCM + SHA-256 key derivation + user_tag derivation
+│   └── sync.py            Pinata IPFS: upload/download/find_latest/unpin
+│                           + CID persistence (.latest_cid) + gzip compression
+└── interfaces/
+    └── mcp_server.py      FastMCP server — 6 tools (stdio transport)
+```
+
+**Hermes plugin** at `plugins/hermes/__init__.py` — full ABC memory provider with prefetch, sync_turn, session hooks, and 7 tool actions.
+
+## Storage
+
+Single SQLite file per namespace with WAL journal mode:
+
+| Table | Columns | Purpose |
+|-------|---------|---------|
+| `entities` | id, name, type, properties, created_at, updated_at | Knowledge graph nodes |
+| `relationships` | id, source_id, target_id, type, properties, valid_from, valid_to, created_at | Typed edges with temporal validity |
+| `episodes` | id, type, content, session_id, timestamp, metadata | Conversation timeline |
+| `decisions` | id, decision, reason, topic, related_entities, timestamp, superseded_by, session_id | Decision ledger |
+| `embeddings` | id, source_type, source_id, content, vector, timestamp | Vector embeddings (1024d BLOB) |
+| `user_profile` | key, value, category, confidence, updated_at | User traits with confidence |
+
+Plus 4 FTS5 virtual tables: `episodes_fts`, `entities_fts`, `decisions_fts`, `user_profile_fts`.
+
+Plus 10 indexes on frequently queried columns.
+
+## IPFS Backup & Restore
+
+Data flow: SQLite → iterdump → gzip → AES-256-GCM encrypt → Pinata IPFS pin
+
+Restore flow: Pinata fetch → AES-256-GCM decrypt → gzip decompress → state-machine SQL parser → filter core table INSERTs → apply on fresh schema
+
+Safeguards:
+- CID persisted to `.latest_cid` file before unpinning old snapshot
+- Safety check refuses to sync if total_rows == 0
+- Auto-sync every 5 store operations
+- Background sync loop every 120 seconds (configurable via SYNC_INTERVAL)
+- On startup: check local `.latest_cid` first, fallback to Pinata search by user_tag
+
+### Switch Devices
+
+1. Install KausaMemory on new device
+2. Set the same `MEMORY_PASSPHRASE` and `PINATA_API_KEY`
+3. Start your agent — data auto-restores from IPFS
+
+## Configuration
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `MEMORY_PASSPHRASE` | Yes | — | AES-256-GCM encryption passphrase |
+| `PINATA_API_KEY` | Yes | — | IPFS pinning via Pinata |
+| `LLM_API_KEY` | No | — | Enables auto entity/decision/trait extraction |
+| `LLM_PROVIDER` | No | `openai` | `openai`, `anthropic`, or `openrouter` |
+| `LLM_MODEL` | No | per-provider default | Extraction model |
+| `LLM_BASE_URL` | No | per-provider default | Custom API endpoint |
+| `EMBEDDING_MODEL` | No | `BAAI/bge-large-en-v1.5` | Local embedding model (FastEmbed) |
+| `KAUSAMEMORY_DATA` | No | `~/.kausamemory` | Storage directory |
+| `KAUSAMEMORY_NAMESPACE` | No | `default` | Agent namespace |
+| `SYNC_INTERVAL` | No | `120` | Background sync interval (seconds) |
+
+Default models per provider: OpenAI → gpt-4o-mini, Anthropic → claude-sonnet-4-20250514, OpenRouter → google/gemini-2.0-flash-001.
+
+## API Reference
+
+### MemoryEngine — 15 Public Methods
+
+**Core (6):**
+- `__init__(namespace=None, shared_read=None)` — config from env vars
+- `startup()` — async, load from IPFS + start background sync
+- `store(user_message, ai_response)` — async, store + extract + auto-sync every 5
+- `retrieve(query, depth="full")` — sync, returns formatted context string
+- `search(query, type="all", limit=10)` — sync, generic search, returns string
+- `status()` — sync, returns dict with all counts
+
+**Typed Search (4):**
+- `search_entities(name=None, type=None, limit=10)` — returns list[dict]
+- `search_decisions(query, limit=10, active_only=True)` — returns list[dict]
+- `search_text(query, limit=10)` — returns list[dict]
+- `search_similar(query, limit=10, min_similarity=0.3)` — returns list[dict]
+
+**Profile (3):**
+- `get_profile(category=None)` — returns list[dict]
+- `set_profile(key, value, category="general", confidence=0.5)` — sync
+- `forget_profile(key)` — returns bool
+
+**Forget (2):**
+- `forget_entity(name)` — returns int (count removed)
+- `forget_decision(topic)` — returns int
+
+**Sync (1):**
+- `force_sync()` — async, returns dict with success + cid
+
+## Requirements
+
+- Python 3.10+
+- ~1.5 GB disk (FastEmbed model downloads on first use)
+- Internet for IPFS sync and LLM extraction (both optional for local-only use)
+
+## License
+
+Apache 2.0
+
+## Links
+
+- [KausaLayer](https://kausalayer.com)
+- [Documentation](https://docs.kausalayer.com)
+- [Twitter/X](https://x.com/kausalayer)

kausamemory-2.1.0/kausamemory/config.py

@@ -0,0 +1,31 @@
+import os
+from pathlib import Path
+
+# Wajib
+MEMORY_PASSPHRASE = os.environ.get("MEMORY_PASSPHRASE", "")
+PINATA_API_KEY = os.environ.get("PINATA_API_KEY", "")
+LLM_API_KEY = os.environ.get("LLM_API_KEY", "")
+
+# Opsional
+LLM_PROVIDER = os.environ.get("LLM_PROVIDER", "openai")  # "openai", "anthropic", or "openrouter"
+LLM_MODEL = os.environ.get("LLM_MODEL", "")  # empty = default per provider
+LLM_BASE_URL = os.environ.get("LLM_BASE_URL", "")  # custom base URL for OpenRouter etc
+EMBEDDING_MODEL = os.environ.get("EMBEDDING_MODEL", "BAAI/bge-large-en-v1.5")
+DATA_DIR = Path(os.environ.get("KAUSAMEMORY_DATA", str(Path.home() / ".kausamemory")))
+SYNC_INTERVAL_SECONDS = int(os.environ.get("SYNC_INTERVAL", "120"))
+
+# Multi-agent namespace: isolate memory per agent identity
+NAMESPACE = os.environ.get("KAUSAMEMORY_NAMESPACE", "default")
+
+# Default model per provider
+DEFAULT_MODELS = {
+    "openai": "gpt-4o-mini",
+    "anthropic": "claude-sonnet-4-20250514",
+    "openrouter": "google/gemini-2.0-flash-001",
+}
+
+# Default base URLs per provider
+DEFAULT_BASE_URLS = {
+    "openai": "https://api.openai.com/v1",
+    "openrouter": "https://openrouter.ai/api/v1",
+}

kausamemory-2.1.0/kausamemory/crypto/encryption.py

@@ -0,0 +1,36 @@
+import os as _os
+import hashlib
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+
+class MemoryEncryption:
+    """Encrypt/decrypt memory data using AES-256-GCM derived from passphrase."""
+
+    @staticmethod
+    def derive_key(passphrase: str) -> bytes:
+        """Derive AES-256 key from passphrase using SHA-256."""
+        return hashlib.sha256(passphrase.encode("utf-8")).digest()
+
+    @staticmethod
+    def derive_user_tag(passphrase: str) -> str:
+        """Derive user identifier tag from passphrase (double hash so key != tag)."""
+        key_hash = hashlib.sha256(passphrase.encode("utf-8")).hexdigest()
+        return hashlib.sha256(("kausa_tag:" + key_hash).encode("utf-8")).hexdigest()[:32]
+
+    @staticmethod
+    def encrypt(data: bytes, passphrase: str) -> bytes:
+        """Encrypt data with AES-256-GCM. Returns nonce(12) + ciphertext."""
+        key = MemoryEncryption.derive_key(passphrase)
+        nonce = _os.urandom(12)
+        aesgcm = AESGCM(key)
+        ciphertext = aesgcm.encrypt(nonce, data, None)
+        return nonce + ciphertext
+
+    @staticmethod
+    def decrypt(encrypted: bytes, passphrase: str) -> bytes:
+        """Decrypt AES-256-GCM data. Input: nonce(12) + ciphertext."""
+        key = MemoryEncryption.derive_key(passphrase)
+        nonce = encrypted[:12]
+        ciphertext = encrypted[12:]
+        aesgcm = AESGCM(key)
+        return aesgcm.decrypt(nonce, ciphertext, None)