axor-memory-sqlite 0.1.0__tar.gz

axor_memory_sqlite-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,88 @@
+name: CI/CD
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*.*.*"]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Checkout axor-core
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ github.repository_owner }}/axor-core
+          path: axor-core
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install
+        run: |
+          pip install -e axor-core/
+          pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -q
+
+  publish:
+    name: Publish to PyPI
+    needs: test
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment: pypi
+
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Verify tag matches package version
+        run: |
+          python - << 'EOF'
+          import pathlib
+          import re
+          import sys
+          import tomllib
+
+          ref = "${{ github.ref_name }}"
+          m = re.fullmatch(r"v(\d+\.\d+\.\d+)", ref)
+          if not m:
+              print(f"Tag {ref!r} must match vX.Y.Z")
+              sys.exit(1)
+
+          tag_version = m.group(1)
+          data = tomllib.loads(pathlib.Path("pyproject.toml").read_text(encoding="utf-8"))
+          pkg_version = data["project"]["version"]
+
+          if tag_version != pkg_version:
+              print(f"Version mismatch: tag={tag_version}, pyproject={pkg_version}")
+              sys.exit(1)
+
+          print(f"Version check passed: {pkg_version}")
+          EOF
+
+      - name: Build
+        run: |
+          pip install hatchling build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

axor_memory_sqlite-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+.pytest_cache/
+.coverage
+dist/
+build/
+*.egg-info/

axor_memory_sqlite-0.1.0/PKG-INFO

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: axor-memory-sqlite
+Version: 0.1.0
+Summary: SQLite memory provider for axor-core
+Project-URL: Repository, https://github.com/Bucha11/axor-memory-sqlite
+Project-URL: Bug Tracker, https://github.com/Bucha11/axor-memory-sqlite/issues
+Project-URL: Changelog, https://github.com/Bucha11/axor-memory-sqlite/releases
+License: MIT
+Keywords: agents,axor,memory,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: axor-core>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# axor-memory-sqlite
+
+[![CI](https://github.com/Bucha11/axor-memory-sqlite/actions/workflows/ci.yml/badge.svg)](https://github.com/Bucha11/axor-memory-sqlite/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/axor-memory-sqlite)](https://pypi.org/project/axor-memory-sqlite/)
+[![Python](https://img.shields.io/pypi/pyversions/axor-memory-sqlite)](https://pypi.org/project/axor-memory-sqlite/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**SQLite memory provider for [axor-core](https://github.com/Bucha11/axor-core).**
+
+Persistent cross-session memory for governed agents. Zero extra dependencies — uses Python's built-in `sqlite3`.
+
+---
+
+## Installation
+
+```bash
+pip install axor-memory-sqlite
+```
+
+Requires `axor-core >= 0.1.0`.
+
+---
+
+## Quick Start
+
+```python
+import axor_claude
+from axor_core import AgentDefinition, AgentDomain, FragmentValue, MemoryFragment
+from axor_memory_sqlite import SQLiteMemoryProvider
+
+provider = SQLiteMemoryProvider("~/.axor/memory.db")
+
+session = axor_claude.make_session(
+    api_key="sk-ant-...",
+    agent_def=AgentDefinition(
+        name="my-agent",
+        domain=AgentDomain.CODING,
+        personality="You are an expert Python engineer.",
+        memory_namespaces=("my-agent",),   # loaded at every session start
+    ),
+    memory_provider=provider,
+)
+
+result = await session.run("refactor the auth module")
+
+# save what you want to remember next time
+await provider.save([
+    MemoryFragment(
+        namespace="my-agent",
+        key="auth_module_status",
+        content="Auth module refactored to use JWT. Entry point: auth/jwt.py.",
+        value=FragmentValue.KNOWLEDGE,
+    ),
+])
+```
+
+---
+
+## FragmentValue — what gets remembered how
+
+Every `MemoryFragment` has a `value` that controls how the compressor treats it when it appears in `ContextView`:
+
+| Value | Compressor behavior | Typical use |
+|-------|--------------------|----|
+| `PINNED` | Never touched — survives all turns | User preferences, system rules, agent personality |
+| `KNOWLEDGE` | Dedup + error collapse only — no truncation | Project docs, domain context, API specs |
+| `WORKING` | Normal compression pipeline | Task findings, recent tool results |
+| `EPHEMERAL` | Aggressive compression — evicted first | Debug output, one-turn scratch |
+
+Eviction priority: `EPHEMERAL` → `WORKING` → `KNOWLEDGE` → `PINNED` (never evicted).
+
+---
+
+## API
+
+### `SQLiteMemoryProvider(db_path)`
+
+```python
+from axor_memory_sqlite import SQLiteMemoryProvider
+
+provider = SQLiteMemoryProvider("~/.axor/memory.db")  # persistent
+provider = SQLiteMemoryProvider(":memory:")            # in-memory, tests only
+```
+
+All methods are async. I/O runs in a thread pool — async callers are never blocked.
+
+### `save(fragments)`
+
+Upsert by `(namespace, key)` — existing fragments are overwritten:
+
+```python
+await provider.save([
+    MemoryFragment(
+        namespace="my-agent",
+        key="project_stack",
+        content="FastAPI + async SQLAlchemy + PostgreSQL",
+        value=FragmentValue.PINNED,
+        tags=["stack", "tech"],
+    ),
+])
+```
+
+### `load(query)`
+
+```python
+from axor_core import MemoryQuery, FragmentValue
+
+# load all from namespace, pinned first
+fragments = await provider.load(MemoryQuery(
+    namespaces=("my-agent",),
+    max_results=20,
+))
+
+# filter by value
+pinned = await provider.load(MemoryQuery(
+    namespaces=("my-agent",),
+    values=(FragmentValue.PINNED, FragmentValue.KNOWLEDGE),
+    max_results=10,
+))
+```
+
+Results are ordered by priority (`PINNED` first) then by `accessed_at` descending.
+
+### `delete(namespace, keys)`
+
+```python
+n = await provider.delete("my-agent", ["stale_key_1", "stale_key_2"])
+print(f"deleted {n} fragments")
+```
+
+### `evict(namespace, values, max_age_seconds)`
+
+Remove stale fragments by value and/or age:
+
+```python
+# evict all ephemeral fragments
+await provider.evict("my-agent", values=(FragmentValue.EPHEMERAL,))
+
+# evict working fragments older than 24 hours
+await provider.evict(
+    "my-agent",
+    values=(FragmentValue.WORKING,),
+    max_age_seconds=86400,
+)
+```
+
+### `namespaces()`
+
+```python
+ns = await provider.namespaces()
+# ["my-agent", "shared", "project-x"]
+```
+
+### `close()`
+
+```python
+await provider.close()
+```
+
+Call on shutdown. The provider can be used as an async context manager in tests:
+
+```python
+async with SQLiteMemoryProvider(":memory:") as provider:
+    await provider.save([...])
+```
+
+---
+
+## Namespaces
+
+Namespaces are logical groupings — they do not require explicit creation. A namespace exists as soon as you save a fragment with that name.
+
+Recommended pattern:
+
+| Namespace | Content |
+|-----------|---------|
+| `{agent-name}` | Agent-specific memory — not shared |
+| `shared` | Shared across all agents in a project |
+| `project:{name}` | Project-specific facts |
+| `user:{id}` | Per-user preferences |
+
+```python
+# agent reads from its own namespace + shared
+agent = AgentDefinition(
+    name="billing-agent",
+    memory_namespaces=("billing-agent", "shared"),
+)
+```
+
+---
+
+## Schema
+
+```sql
+CREATE TABLE memory_fragments (
+    namespace    TEXT    NOT NULL,
+    key          TEXT    NOT NULL,
+    content      TEXT    NOT NULL,
+    value        TEXT    NOT NULL DEFAULT 'working',
+    token_count  INTEGER NOT NULL DEFAULT 0,
+    tags         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+    created_at   TEXT    NOT NULL,
+    accessed_at  TEXT    NOT NULL,
+    metadata     TEXT    NOT NULL DEFAULT '{}',   -- JSON object
+    PRIMARY KEY (namespace, key)
+);
+```
+
+The database file is a standard SQLite file — readable with any SQLite tool.
+
+---
+
+## Testing
+
+Use `:memory:` for tests — no file created, no cleanup needed:
+
+```python
+import pytest
+from axor_memory_sqlite import SQLiteMemoryProvider
+from axor_core import MemoryFragment, FragmentValue, MemoryQuery
+
+@pytest.mark.asyncio
+async def test_memory():
+    p = SQLiteMemoryProvider(":memory:")
+
+    await p.save([
+        MemoryFragment(namespace="test", key="k1",
+                       content="hello", value=FragmentValue.WORKING),
+    ])
+    results = await p.load(MemoryQuery(namespaces=("test",), max_results=5))
+    assert len(results) == 1
+    assert results[0].content == "hello"
+
+    await p.close()
+```
+
+---
+
+## Requirements
+
+- Python 3.11+
+- `axor-core >= 0.1.0`
+- No extra dependencies — uses stdlib `sqlite3` + `asyncio`
+
+---
+
+## License
+
+MIT

axor_memory_sqlite-0.1.0/README.md

@@ -0,0 +1,249 @@
+# axor-memory-sqlite
+
+[![CI](https://github.com/Bucha11/axor-memory-sqlite/actions/workflows/ci.yml/badge.svg)](https://github.com/Bucha11/axor-memory-sqlite/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/axor-memory-sqlite)](https://pypi.org/project/axor-memory-sqlite/)
+[![Python](https://img.shields.io/pypi/pyversions/axor-memory-sqlite)](https://pypi.org/project/axor-memory-sqlite/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**SQLite memory provider for [axor-core](https://github.com/Bucha11/axor-core).**
+
+Persistent cross-session memory for governed agents. Zero extra dependencies — uses Python's built-in `sqlite3`.
+
+---
+
+## Installation
+
+```bash
+pip install axor-memory-sqlite
+```
+
+Requires `axor-core >= 0.1.0`.
+
+---
+
+## Quick Start
+
+```python
+import axor_claude
+from axor_core import AgentDefinition, AgentDomain, FragmentValue, MemoryFragment
+from axor_memory_sqlite import SQLiteMemoryProvider
+
+provider = SQLiteMemoryProvider("~/.axor/memory.db")
+
+session = axor_claude.make_session(
+    api_key="sk-ant-...",
+    agent_def=AgentDefinition(
+        name="my-agent",
+        domain=AgentDomain.CODING,
+        personality="You are an expert Python engineer.",
+        memory_namespaces=("my-agent",),   # loaded at every session start
+    ),
+    memory_provider=provider,
+)
+
+result = await session.run("refactor the auth module")
+
+# save what you want to remember next time
+await provider.save([
+    MemoryFragment(
+        namespace="my-agent",
+        key="auth_module_status",
+        content="Auth module refactored to use JWT. Entry point: auth/jwt.py.",
+        value=FragmentValue.KNOWLEDGE,
+    ),
+])
+```
+
+---
+
+## FragmentValue — what gets remembered how
+
+Every `MemoryFragment` has a `value` that controls how the compressor treats it when it appears in `ContextView`:
+
+| Value | Compressor behavior | Typical use |
+|-------|--------------------|----|
+| `PINNED` | Never touched — survives all turns | User preferences, system rules, agent personality |
+| `KNOWLEDGE` | Dedup + error collapse only — no truncation | Project docs, domain context, API specs |
+| `WORKING` | Normal compression pipeline | Task findings, recent tool results |
+| `EPHEMERAL` | Aggressive compression — evicted first | Debug output, one-turn scratch |
+
+Eviction priority: `EPHEMERAL` → `WORKING` → `KNOWLEDGE` → `PINNED` (never evicted).
+
+---
+
+## API
+
+### `SQLiteMemoryProvider(db_path)`
+
+```python
+from axor_memory_sqlite import SQLiteMemoryProvider
+
+provider = SQLiteMemoryProvider("~/.axor/memory.db")  # persistent
+provider = SQLiteMemoryProvider(":memory:")            # in-memory, tests only
+```
+
+All methods are async. I/O runs in a thread pool — async callers are never blocked.
+
+### `save(fragments)`
+
+Upsert by `(namespace, key)` — existing fragments are overwritten:
+
+```python
+await provider.save([
+    MemoryFragment(
+        namespace="my-agent",
+        key="project_stack",
+        content="FastAPI + async SQLAlchemy + PostgreSQL",
+        value=FragmentValue.PINNED,
+        tags=["stack", "tech"],
+    ),
+])
+```
+
+### `load(query)`
+
+```python
+from axor_core import MemoryQuery, FragmentValue
+
+# load all from namespace, pinned first
+fragments = await provider.load(MemoryQuery(
+    namespaces=("my-agent",),
+    max_results=20,
+))
+
+# filter by value
+pinned = await provider.load(MemoryQuery(
+    namespaces=("my-agent",),
+    values=(FragmentValue.PINNED, FragmentValue.KNOWLEDGE),
+    max_results=10,
+))
+```
+
+Results are ordered by priority (`PINNED` first) then by `accessed_at` descending.
+
+### `delete(namespace, keys)`
+
+```python
+n = await provider.delete("my-agent", ["stale_key_1", "stale_key_2"])
+print(f"deleted {n} fragments")
+```
+
+### `evict(namespace, values, max_age_seconds)`
+
+Remove stale fragments by value and/or age:
+
+```python
+# evict all ephemeral fragments
+await provider.evict("my-agent", values=(FragmentValue.EPHEMERAL,))
+
+# evict working fragments older than 24 hours
+await provider.evict(
+    "my-agent",
+    values=(FragmentValue.WORKING,),
+    max_age_seconds=86400,
+)
+```
+
+### `namespaces()`
+
+```python
+ns = await provider.namespaces()
+# ["my-agent", "shared", "project-x"]
+```
+
+### `close()`
+
+```python
+await provider.close()
+```
+
+Call on shutdown. The provider can be used as an async context manager in tests:
+
+```python
+async with SQLiteMemoryProvider(":memory:") as provider:
+    await provider.save([...])
+```
+
+---
+
+## Namespaces
+
+Namespaces are logical groupings — they do not require explicit creation. A namespace exists as soon as you save a fragment with that name.
+
+Recommended pattern:
+
+| Namespace | Content |
+|-----------|---------|
+| `{agent-name}` | Agent-specific memory — not shared |
+| `shared` | Shared across all agents in a project |
+| `project:{name}` | Project-specific facts |
+| `user:{id}` | Per-user preferences |
+
+```python
+# agent reads from its own namespace + shared
+agent = AgentDefinition(
+    name="billing-agent",
+    memory_namespaces=("billing-agent", "shared"),
+)
+```
+
+---
+
+## Schema
+
+```sql
+CREATE TABLE memory_fragments (
+    namespace    TEXT    NOT NULL,
+    key          TEXT    NOT NULL,
+    content      TEXT    NOT NULL,
+    value        TEXT    NOT NULL DEFAULT 'working',
+    token_count  INTEGER NOT NULL DEFAULT 0,
+    tags         TEXT    NOT NULL DEFAULT '[]',   -- JSON array
+    created_at   TEXT    NOT NULL,
+    accessed_at  TEXT    NOT NULL,
+    metadata     TEXT    NOT NULL DEFAULT '{}',   -- JSON object
+    PRIMARY KEY (namespace, key)
+);
+```
+
+The database file is a standard SQLite file — readable with any SQLite tool.
+
+---
+
+## Testing
+
+Use `:memory:` for tests — no file created, no cleanup needed:
+
+```python
+import pytest
+from axor_memory_sqlite import SQLiteMemoryProvider
+from axor_core import MemoryFragment, FragmentValue, MemoryQuery
+
+@pytest.mark.asyncio
+async def test_memory():
+    p = SQLiteMemoryProvider(":memory:")
+
+    await p.save([
+        MemoryFragment(namespace="test", key="k1",
+                       content="hello", value=FragmentValue.WORKING),
+    ])
+    results = await p.load(MemoryQuery(namespaces=("test",), max_results=5))
+    assert len(results) == 1
+    assert results[0].content == "hello"
+
+    await p.close()
+```
+
+---
+
+## Requirements
+
+- Python 3.11+
+- `axor-core >= 0.1.0`
+- No extra dependencies — uses stdlib `sqlite3` + `asyncio`
+
+---
+
+## License
+
+MIT

axor_memory_sqlite-0.1.0/axor_memory_sqlite/__init__.py

@@ -0,0 +1,5 @@
+"""axor-memory-sqlite — SQLite MemoryProvider for axor-core."""
+from axor_memory_sqlite.provider import SQLiteMemoryProvider
+
+__version__ = "0.1.0"
+__all__ = ["SQLiteMemoryProvider"]

axor_memory_sqlite-0.1.0/axor_memory_sqlite/provider.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+"""
+SQLite-backed MemoryProvider for axor-core.
+
+Zero external dependencies — uses Python's built-in sqlite3.
+Thread-safe via asyncio.Lock + aiosqlite pattern (runs in thread pool).
+
+Schema:
+
+    CREATE TABLE memory_fragments (
+        namespace   TEXT NOT NULL,
+        key         TEXT NOT NULL,
+        content     TEXT NOT NULL,
+        value       TEXT NOT NULL DEFAULT 'working',
+        token_count INTEGER NOT NULL DEFAULT 0,
+        tags        TEXT NOT NULL DEFAULT '[]',   -- JSON array
+        created_at  TEXT NOT NULL,
+        accessed_at TEXT NOT NULL,
+        metadata    TEXT NOT NULL DEFAULT '{}',   -- JSON object
+        PRIMARY KEY (namespace, key)
+    );
+"""
+
+import asyncio
+import json
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from axor_core.contracts.memory import (
+    MemoryFragment,
+    MemoryProvider,
+    MemoryQuery,
+    FragmentValue,
+)
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS memory_fragments (
+    namespace    TEXT    NOT NULL,
+    key          TEXT    NOT NULL,
+    content      TEXT    NOT NULL,
+    value        TEXT    NOT NULL DEFAULT 'working',
+    token_count  INTEGER NOT NULL DEFAULT 0,
+    tags         TEXT    NOT NULL DEFAULT '[]',
+    created_at   TEXT    NOT NULL,
+    accessed_at  TEXT    NOT NULL,
+    metadata     TEXT    NOT NULL DEFAULT '{}',
+    PRIMARY KEY (namespace, key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_namespace ON memory_fragments(namespace);
+CREATE INDEX IF NOT EXISTS idx_value     ON memory_fragments(value);
+CREATE INDEX IF NOT EXISTS idx_accessed  ON memory_fragments(accessed_at);
+"""
+
+_NOW = lambda: datetime.now(timezone.utc).isoformat()
+
+
+def _row_to_fragment(row: tuple) -> MemoryFragment:
+    ns, key, content, value, token_count, tags_json, created_at, accessed_at, meta_json = row
+    return MemoryFragment(
+        namespace=ns,
+        key=key,
+        content=content,
+        value=FragmentValue(value),
+        token_count=token_count,
+        tags=json.loads(tags_json),
+        created_at=datetime.fromisoformat(created_at),
+        accessed_at=datetime.fromisoformat(accessed_at),
+        metadata=json.loads(meta_json),
+    )
+
+
+class SQLiteMemoryProvider(MemoryProvider):
+    """
+    SQLite-backed MemoryProvider.
+
+    All I/O runs in a thread pool via asyncio.to_thread()
+    so async callers are never blocked.
+
+    Usage:
+
+        from axor_memory_sqlite import SQLiteMemoryProvider
+        from axor_core import GovernedSession, AgentDefinition
+
+        provider = SQLiteMemoryProvider("~/.axor/memory.db")
+
+        session = GovernedSession(
+            executor=...,
+            capability_executor=...,
+            agent_def=AgentDefinition(
+                name="my-agent",
+                memory_namespaces=("my-agent", "shared"),
+            ),
+            memory_provider=provider,
+        )
+
+        # save memory after a session
+        await session.save_memory(
+            key="last_project",
+            content="Working on axor federation support",
+            value=FragmentValue.WORKING,
+        )
+    """
+
+    def __init__(self, db_path: str | Path = ":memory:") -> None:
+        self._db_path = str(Path(db_path).expanduser()) if db_path != ":memory:" else ":memory:"
+        self._lock    = asyncio.Lock()
+        self._conn: sqlite3.Connection | None = None
+
+    def _open(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self._conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            self._conn.row_factory = sqlite3.Row
+            self._conn.executescript(_SCHEMA)
+            self._conn.commit()
+        return self._conn
+
+    async def _run(self, fn):
+        """Run a blocking DB call in thread pool."""
+        return await asyncio.to_thread(fn)
+
+    # ── MemoryProvider interface ────────────────────────────────────────────────
+
+    async def load(self, query: MemoryQuery) -> list[MemoryFragment]:
+        def _load():
+            conn = self._open()
+            parts: list[str] = []
+            params: list[Any] = []
+
+            if query.namespaces:
+                placeholders = ",".join("?" * len(query.namespaces))
+                parts.append(f"namespace IN ({placeholders})")
+                params.extend(query.namespaces)
+
+            if query.values:
+                placeholders = ",".join("?" * len(query.values))
+                parts.append(f"value IN ({placeholders})")
+                params.extend(v.value for v in query.values)
+
+            where = ("WHERE " + " AND ".join(parts)) if parts else ""
+            sql = f"""
+                SELECT namespace, key, content, value, token_count, tags,
+                       created_at, accessed_at, metadata
+                FROM memory_fragments
+                {where}
+                ORDER BY
+                    CASE value
+                        WHEN 'pinned'    THEN 0
+                        WHEN 'knowledge' THEN 1
+                        WHEN 'working'   THEN 2
+                        WHEN 'ephemeral' THEN 3
+                    END,
+                    accessed_at DESC
+                LIMIT ?
+            """
+            params.append(query.max_results)
+            rows = conn.execute(sql, params).fetchall()
+            return [_row_to_fragment(tuple(r)) for r in rows]
+
+        try:
+            async with self._lock:
+                return await self._run(_load)
+        except Exception:
+            return []
+
+    async def save(self, fragments: list[MemoryFragment]) -> None:
+        def _save():
+            conn = self._open()
+            now  = _NOW()
+            rows = [
+                (
+                    f.namespace,
+                    f.key,
+                    f.content,
+                    f.value.value,
+                    f.token_count or len(f.content) // 4,
+                    json.dumps(f.tags),
+                    f.created_at.isoformat() if f.created_at else now,
+                    now,
+                    json.dumps(f.metadata),
+                )
+                for f in fragments
+            ]
+            conn.executemany("""
+                INSERT INTO memory_fragments
+                    (namespace, key, content, value, token_count, tags,
+                     created_at, accessed_at, metadata)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(namespace, key) DO UPDATE SET
+                    content     = excluded.content,
+                    value       = excluded.value,
+                    token_count = excluded.token_count,
+                    tags        = excluded.tags,
+                    accessed_at = excluded.accessed_at,
+                    metadata    = excluded.metadata
+            """, rows)
+            conn.commit()
+
+        try:
+            async with self._lock:
+                await self._run(_save)
+        except Exception:
+            pass
+
+    async def delete(self, namespace: str, keys: list[str]) -> int:
+        def _delete():
+            conn = self._open()
+            placeholders = ",".join("?" * len(keys))
+            cur = conn.execute(
+                f"DELETE FROM memory_fragments WHERE namespace=? AND key IN ({placeholders})",
+                [namespace, *keys],
+            )
+            conn.commit()
+            return cur.rowcount
+
+        try:
+            async with self._lock:
+                return await self._run(_delete)
+        except Exception:
+            return 0
+
+    async def evict(
+        self,
+        namespace: str,
+        values: tuple[FragmentValue, ...] = (FragmentValue.EPHEMERAL,),
+        max_age_seconds: int | None = None,
+    ) -> int:
+        def _evict():
+            conn = self._open()
+            parts: list[str] = ["namespace = ?"]
+            params: list[Any] = [namespace]
+
+            if values:
+                placeholders = ",".join("?" * len(values))
+                parts.append(f"value IN ({placeholders})")
+                params.extend(v.value for v in values)
+
+            if max_age_seconds is not None:
+                parts.append(
+                    "accessed_at < datetime('now', ?)"
+                )
+                params.append(f"-{max_age_seconds} seconds")
+
+            where = " AND ".join(parts)
+            cur = conn.execute(
+                f"DELETE FROM memory_fragments WHERE {where}",
+                params,
+            )
+            conn.commit()
+            return cur.rowcount
+
+        try:
+            async with self._lock:
+                return await self._run(_evict)
+        except Exception:
+            return 0
+
+    async def namespaces(self) -> list[str]:
+        def _ns():
+            conn = self._open()
+            rows = conn.execute(
+                "SELECT DISTINCT namespace FROM memory_fragments ORDER BY namespace"
+            ).fetchall()
+            return [r[0] for r in rows]
+
+        try:
+            async with self._lock:
+                return await self._run(_ns)
+        except Exception:
+            return []
+
+    async def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None

axor_memory_sqlite-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "axor-memory-sqlite"
+version = "0.1.0"
+description = "SQLite memory provider for axor-core"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+keywords = ["axor", "memory", "sqlite", "agents"]
+classifiers = [
+	"Development Status :: 3 - Alpha",
+	"Intended Audience :: Developers",
+	"License :: OSI Approved :: MIT License",
+	"Programming Language :: Python :: 3.11",
+	"Programming Language :: Python :: 3.12",
+	"Topic :: Database",
+	"Topic :: Software Development :: Libraries",
+]
+dependencies = ["axor-core>=0.1.0"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[project.urls]
+Repository = "https://github.com/Bucha11/axor-memory-sqlite"
+"Bug Tracker" = "https://github.com/Bucha11/axor-memory-sqlite/issues"
+Changelog = "https://github.com/Bucha11/axor-memory-sqlite/releases"
+
+[tool.hatch.build.targets.wheel]
+packages = ["axor_memory_sqlite"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

axor_memory_sqlite-0.1.0/tests/test_provider.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import pytest
+
+from axor_core.contracts.memory import FragmentValue, MemoryFragment, MemoryQuery
+from axor_memory_sqlite import SQLiteMemoryProvider
+
+
+@pytest.mark.asyncio
+async def test_save_and_load_orders_by_value_priority() -> None:
+    provider = SQLiteMemoryProvider(":memory:")
+    try:
+        await provider.save([
+            MemoryFragment(namespace="agent", key="working", content="w", value=FragmentValue.WORKING),
+            MemoryFragment(namespace="agent", key="pinned", content="p", value=FragmentValue.PINNED),
+        ])
+
+        fragments = await provider.load(MemoryQuery(namespaces=("agent",), max_results=10))
+
+        assert [fragment.key for fragment in fragments] == ["pinned", "working"]
+    finally:
+        await provider.close()
+
+
+@pytest.mark.asyncio
+async def test_delete_and_namespaces() -> None:
+    provider = SQLiteMemoryProvider(":memory:")
+    try:
+        await provider.save([
+            MemoryFragment(namespace="agent-a", key="one", content="a", value=FragmentValue.KNOWLEDGE),
+            MemoryFragment(namespace="agent-b", key="two", content="b", value=FragmentValue.EPHEMERAL),
+        ])
+
+        namespaces = await provider.namespaces()
+        deleted = await provider.delete("agent-a", ["one"])
+        remaining = await provider.load(MemoryQuery(namespaces=("agent-a", "agent-b"), max_results=10))
+
+        assert namespaces == ["agent-a", "agent-b"]
+        assert deleted == 1
+        assert [fragment.namespace for fragment in remaining] == ["agent-b"]
+    finally:
+        await provider.close()
+
+
+@pytest.mark.asyncio
+async def test_evict_by_value() -> None:
+    provider = SQLiteMemoryProvider(":memory:")
+    try:
+        old = datetime(2000, 1, 1, tzinfo=timezone.utc)
+        await provider.save([
+            MemoryFragment(namespace="agent", key="old", content="x", value=FragmentValue.EPHEMERAL, created_at=old),
+            MemoryFragment(namespace="agent", key="keep", content="y", value=FragmentValue.PINNED, created_at=old),
+        ])
+
+        removed = await provider.evict("agent", values=(FragmentValue.EPHEMERAL,))
+        remaining = await provider.load(MemoryQuery(namespaces=("agent",), max_results=10))
+
+        assert removed == 1
+        assert [fragment.key for fragment in remaining] == ["keep"]
+    finally:
+        await provider.close()