boring-agent-memory 0.2.2__py3-none-any.whl

boring_agent_memory/query.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import re
+import sqlite3
+from collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from .schema import connect, init_db, require_index
+from .snippets import plain_snippet
+
+
+@dataclass(frozen=True)
+class QueryResult:
+    id: str
+    chunk_id: str
+    source_type: str
+    source_path: str
+    workspace: str
+    title: str
+    heading: str
+    start_line: int
+    end_line: int
+    citation: str
+    score: float
+    snippet: str
+    strategy: str
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+def query_memory(
+    db_path: Path | str,
+    query: str,
+    limit: int = 5,
+    source_type: str | None = None,
+    workspace: Path | str | None = None,
+) -> list[QueryResult]:
+    conn = connect(require_index(db_path))
+    init_db(conn)
+    try:
+        workspace_path = Path(workspace).expanduser().resolve() if workspace else None
+        results = _query_memory(conn, query, limit, source_type, workspace_path)
+    finally:
+        conn.close()
+    return results
+
+
+def _query_memory(
+    conn: sqlite3.Connection,
+    query: str,
+    limit: int,
+    source_type: str | None,
+    workspace: Path | None,
+) -> list[QueryResult]:
+    if limit <= 0:
+        return []
+
+    seen_documents: set[str] = set()
+    results: list[QueryResult] = []
+
+    def collect(rows: Iterable[sqlite3.Row], strategy: str) -> bool:
+        # Rows are chunks but results are documents, so read only until enough distinct documents appear.
+        for row in rows:
+            if row["id"] in seen_documents:
+                continue
+            seen_documents.add(row["id"])
+            results.append(row_to_result(row, strategy, query))
+            if len(results) >= limit:
+                return True
+        return False
+
+    for strategy, fts_query in build_fts_queries(query):
+        try:
+            if collect(run_fts_query(conn, fts_query, source_type, workspace), strategy):
+                return results
+        except sqlite3.DatabaseError:
+            continue
+
+    collect(run_like_query(conn, query, source_type, workspace), "like")
+    return results
+
+
+def build_fts_queries(query: str) -> list[tuple[str, str]]:
+    cleaned = query.strip()
+    tokens = tokenize_query(cleaned)
+    queries: list[tuple[str, str]] = []
+
+    if cleaned:
+        queries.append(("phrase", quote_fts(cleaned)))
+    if tokens:
+        queries.append(("and", " AND ".join(quote_fts(token) for token in tokens)))
+        queries.append(("or", " OR ".join(quote_fts(token) for token in tokens)))
+    return queries
+
+
+def tokenize_query(query: str) -> list[str]:
+    tokens = re.findall(r"[A-Za-z0-9_./:-]+|[\u4e00-\u9fff]+", query)
+    return [token.strip("./:-") for token in tokens if token.strip("./:-")]
+
+
+def quote_fts(value: str) -> str:
+    return '"' + value.replace('"', '""') + '"'
+
+
+def run_fts_query(
+    conn: sqlite3.Connection,
+    fts_query: str,
+    source_type: str | None,
+    workspace: Path | None,
+) -> Iterable[sqlite3.Row]:
+    params: list[object] = [fts_query]
+    source_filter = ""
+    if source_type:
+        source_filter = "AND d.source_type = ?"
+        params.append(source_type)
+    workspace_filter = ""
+    if workspace:
+        workspace_filter = "AND d.workspace = ?"
+        params.append(workspace.as_posix())
+
+    return conn.execute(
+        f"""
+        SELECT
+          d.id,
+          c.id AS chunk_id,
+          d.source_type,
+          d.source_path,
+          d.workspace,
+          d.title,
+          c.heading,
+          c.start_line,
+          c.end_line,
+          rank AS score,
+          snippet(chunks_fts, 3, '[', ']', '...', 28) AS snippet
+        FROM chunks_fts
+        JOIN chunks c ON c.id = chunks_fts.chunk_id
+        JOIN documents d ON d.id = c.document_id
+        WHERE chunks_fts MATCH ?
+        AND rank MATCH 'bm25(0.0, 2.5, 1.8, 1.0, 0.25)'
+        {source_filter}
+        {workspace_filter}
+        ORDER BY rank ASC, c.id ASC
+        """,
+        params,
+    )
+
+
+def escape_like(value: str) -> str:
+    """Escape LIKE wildcards so the query is matched as literal text."""
+    return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+
+
+def run_like_query(
+    conn: sqlite3.Connection,
+    query: str,
+    source_type: str | None,
+    workspace: Path | None,
+) -> Iterable[sqlite3.Row]:
+    like = f"%{escape_like(query.lower())}%"
+    params: list[object] = [like, like, like, like]
+    source_filter = ""
+    if source_type:
+        source_filter = "AND d.source_type = ?"
+        params.append(source_type)
+    workspace_filter = ""
+    if workspace:
+        workspace_filter = "AND d.workspace = ?"
+        params.append(workspace.as_posix())
+    params.extend([like, like])
+
+    return conn.execute(
+        f"""
+        SELECT
+          d.id,
+          c.id AS chunk_id,
+          d.source_type,
+          d.source_path,
+          d.workspace,
+          d.title,
+          c.heading,
+          c.start_line,
+          c.end_line,
+          999.0 AS score,
+          c.content AS snippet
+        FROM chunks c
+        JOIN documents d ON d.id = c.document_id
+        WHERE (
+          lower(d.title) LIKE ? ESCAPE '\\'
+          OR lower(c.heading) LIKE ? ESCAPE '\\'
+          OR lower(c.content) LIKE ? ESCAPE '\\'
+          OR lower(d.source_path) LIKE ? ESCAPE '\\'
+        )
+        {source_filter}
+        {workspace_filter}
+        ORDER BY
+          CASE
+            WHEN lower(d.title) LIKE ? ESCAPE '\\' THEN 0
+            WHEN lower(d.source_path) LIKE ? ESCAPE '\\' THEN 1
+            ELSE 2
+          END,
+          d.title ASC,
+          c.ordinal ASC
+        """,
+        params,
+    )
+
+
+def row_to_result(row: sqlite3.Row, strategy: str, query: str) -> QueryResult:
+    snippet = row["snippet"]
+    if strategy == "like":
+        snippet = plain_snippet(snippet, query)
+    heading = row["heading"]
+    location = f"L{row['start_line']}-L{row['end_line']}"
+    citation = f"{row['source_path']}:{location}"
+    if heading:
+        citation = f"{row['source_path']}#{heading}:{location}"
+    return QueryResult(
+        id=row["id"],
+        chunk_id=row["chunk_id"],
+        source_type=row["source_type"],
+        source_path=row["source_path"],
+        workspace=row["workspace"],
+        title=row["title"],
+        heading=heading,
+        start_line=int(row["start_line"]),
+        end_line=int(row["end_line"]),
+        citation=citation,
+        score=float(row["score"]),
+        snippet=snippet,
+        strategy=strategy,
+    )

boring_agent_memory/schema.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from .chunking import chunk_text
+
+DEFAULT_DB_PATH = Path(".bam/memory.db")
+SCHEMA_VERSION = 2
+
+
+def require_index(db_path: Path | str) -> Path:
+    """Reject a missing index, because connecting would silently create an empty one."""
+    path = Path(db_path).expanduser()
+    if not path.exists():
+        raise FileNotFoundError(f"index does not exist: {path}; run bam build first")
+    return path
+
+
+def connect(db_path: Path | str = DEFAULT_DB_PATH) -> sqlite3.Connection:
+    path = Path(db_path).expanduser()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(path)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    conn.execute("PRAGMA secure_delete=ON")
+    return conn
+
+
+def init_db(conn: sqlite3.Connection) -> None:
+    """Create or transactionally migrate the index schema."""
+    version = schema_version(conn)
+    if version > SCHEMA_VERSION:
+        raise sqlite3.DatabaseError(
+            f"index schema {version} is newer than supported schema {SCHEMA_VERSION}"
+        )
+
+    has_legacy_records = _table_exists(conn, "records")
+    if version == SCHEMA_VERSION and not has_legacy_records:
+        _enable_fts_secure_delete(conn)
+        return
+
+    started_transaction = not conn.in_transaction
+    if started_transaction:
+        conn.execute("BEGIN IMMEDIATE")
+    try:
+        if has_legacy_records:
+            _migrate_v1_to_v2(conn)
+        else:
+            _create_v2_schema(conn)
+        conn.execute(f"PRAGMA user_version={SCHEMA_VERSION}")
+        _enable_fts_secure_delete(conn)
+        if started_transaction:
+            conn.commit()
+    except Exception:
+        if started_transaction:
+            conn.rollback()
+        raise
+
+
+def schema_version(conn: sqlite3.Connection) -> int:
+    return int(conn.execute("PRAGMA user_version").fetchone()[0])
+
+
+def fts5_available(conn: sqlite3.Connection) -> bool:
+    try:
+        conn.execute(
+            "CREATE VIRTUAL TABLE IF NOT EXISTS temp._bam_fts5_probe USING fts5(x)"
+        )
+        conn.execute("DROP TABLE IF EXISTS temp._bam_fts5_probe")
+        return True
+    except sqlite3.DatabaseError:
+        return False
+
+
+def clear_index(conn: sqlite3.Connection) -> None:
+    """Clear index rows inside the caller's transaction."""
+    conn.execute("DELETE FROM chunks_fts")
+    conn.execute("DELETE FROM chunks")
+    conn.execute("DELETE FROM documents")
+    conn.execute("DELETE FROM index_metadata")
+
+
+def _create_v2_schema(conn: sqlite3.Connection) -> None:
+    statements = (
+        """CREATE TABLE IF NOT EXISTS documents (
+          id TEXT PRIMARY KEY,
+          source_type TEXT NOT NULL,
+          source_path TEXT NOT NULL,
+          workspace TEXT NOT NULL,
+          title TEXT NOT NULL,
+          content TEXT NOT NULL,
+          source_hash TEXT NOT NULL,
+          content_hash TEXT NOT NULL,
+          metadata_json TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          UNIQUE(workspace, source_type, source_path)
+        )""",
+        """CREATE INDEX IF NOT EXISTS idx_documents_source_type
+          ON documents(source_type)""",
+        """CREATE INDEX IF NOT EXISTS idx_documents_workspace
+          ON documents(workspace)""",
+        """CREATE INDEX IF NOT EXISTS idx_documents_source_hash
+          ON documents(source_hash)""",
+        """CREATE TABLE IF NOT EXISTS chunks (
+          id TEXT PRIMARY KEY,
+          document_id TEXT NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+          heading TEXT NOT NULL,
+          heading_key TEXT NOT NULL,
+          ordinal INTEGER NOT NULL,
+          start_line INTEGER NOT NULL,
+          end_line INTEGER NOT NULL,
+          content TEXT NOT NULL,
+          content_hash TEXT NOT NULL,
+          UNIQUE(document_id, heading_key, ordinal)
+        )""",
+        """CREATE INDEX IF NOT EXISTS idx_chunks_document_id
+          ON chunks(document_id)""",
+        """CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+          chunk_id UNINDEXED,
+          title,
+          heading,
+          content,
+          source_path,
+          tokenize = 'unicode61'
+        )""",
+        """CREATE TABLE IF NOT EXISTS index_metadata (
+          singleton INTEGER PRIMARY KEY CHECK(singleton = 1),
+          config_fingerprint TEXT NOT NULL,
+          config_json TEXT NOT NULL,
+          built_at TEXT NOT NULL,
+          chunker_version INTEGER NOT NULL,
+          chunk_size INTEGER NOT NULL
+        )""",
+        """CREATE VIEW IF NOT EXISTS records AS
+          SELECT
+            id, source_type, source_path, workspace, title, content,
+            content_hash, metadata_json, updated_at
+          FROM documents""",
+    )
+    for statement in statements:
+        conn.execute(statement)
+
+
+def _migrate_v1_to_v2(conn: sqlite3.Connection) -> None:
+    legacy_rows = conn.execute("SELECT * FROM records ORDER BY source_path").fetchall()
+    conn.execute("DROP TABLE IF EXISTS records_fts")
+    conn.execute("ALTER TABLE records RENAME TO legacy_records")
+    _create_v2_schema(conn)
+
+    for row in legacy_rows:
+        chunk = chunk_text(row["id"], row["content"], "", max_chars=0)[0]
+        conn.execute(
+            """
+            INSERT INTO documents (
+              id, source_type, source_path, workspace, title, content,
+              source_hash, content_hash, metadata_json, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                row["id"],
+                row["source_type"],
+                row["source_path"],
+                row["workspace"],
+                row["title"],
+                row["content"],
+                "",
+                chunk.content_hash,
+                row["metadata_json"],
+                row["updated_at"],
+            ),
+        )
+        conn.execute(
+            """
+            INSERT INTO chunks (
+              id, document_id, heading, heading_key, ordinal,
+              start_line, end_line, content, content_hash
+            ) VALUES (?, ?, '', 'document', 0, 1, ?, ?, ?)
+            """,
+            (
+                chunk.id,
+                row["id"],
+                chunk.end_line,
+                chunk.content,
+                chunk.content_hash,
+            ),
+        )
+        conn.execute(
+            """
+            INSERT INTO chunks_fts (chunk_id, title, heading, content, source_path)
+            VALUES (?, ?, '', ?, ?)
+            """,
+            (chunk.id, row["title"], chunk.content, row["source_path"]),
+        )
+
+    conn.execute("DROP TABLE legacy_records")
+
+
+def _table_exists(conn: sqlite3.Connection, table: str) -> bool:
+    row = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?",
+        (table,),
+    ).fetchone()
+    return row is not None
+
+
+def _enable_fts_secure_delete(conn: sqlite3.Connection) -> None:
+    try:
+        conn.execute("INSERT INTO chunks_fts(chunks_fts, rank) VALUES('secure-delete', 1)")
+    except sqlite3.DatabaseError:
+        pass

boring_agent_memory/server.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import TextIO
+
+from .query import query_memory
+
+
+def serve_stdio(
+    db_path: Path | str,
+    stdin: TextIO = sys.stdin,
+    stdout: TextIO = sys.stdout,
+) -> int:
+    for line in stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            request = json.loads(line)
+            query = str(request["query"])
+            limit = int(request.get("limit", 5))
+            source_type = request.get("source_type")
+            workspace = request.get("workspace")
+            results = [
+                result.to_dict()
+                for result in query_memory(
+                    db_path,
+                    query,
+                    limit=limit,
+                    source_type=source_type,
+                    workspace=workspace,
+                )
+            ]
+            response = {"ok": True, "query": query, "results": results}
+        except Exception as exc:  # noqa: BLE001 - stdio server must report errors as data.
+            response = {"ok": False, "error": str(exc)}
+        stdout.write(json.dumps(response, ensure_ascii=False) + "\n")
+        stdout.flush()
+    return 0

boring_agent_memory/snippets.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import re
+
+
+def plain_snippet(content: str, query: str, max_chars: int = 220) -> str:
+    if not content:
+        return ""
+
+    terms = [t for t in re.findall(r"[\w\u4e00-\u9fff]+", query, flags=re.UNICODE) if t]
+    lower = content.lower()
+    start = 0
+    for term in terms:
+        idx = lower.find(term.lower())
+        if idx >= 0:
+            start = max(0, idx - max_chars // 3)
+            break
+
+    snippet = content[start : start + max_chars].replace("\n", " ")
+    snippet = re.sub(r"\s+", " ", snippet).strip()
+    if start > 0:
+        snippet = "..." + snippet
+    if start + max_chars < len(content):
+        snippet += "..."
+    return snippet
+

boring_agent_memory-0.2.2.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: boring-agent-memory
+Version: 0.2.2
+Summary: A boring, local-first BM25 memory layer for AI agents.
+Author: Boring Agent Memory contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hskl18/boring-agent-memory
+Project-URL: Repository, https://github.com/hskl18/boring-agent-memory
+Project-URL: Issues, https://github.com/hskl18/boring-agent-memory/issues
+Keywords: agent-memory,bm25,sqlite,fts5,rag,local-first,retrieval,source-grounded,privacy-preserving
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: embeddings
+Requires-Dist: fastembed<0.9,>=0.8.0; extra == "embeddings"
+Dynamic: license-file
+
+# Boring Agent Memory
+
+[![tests](https://github.com/hskl18/boring-agent-memory/actions/workflows/tests.yml/badge.svg)](https://github.com/hskl18/boring-agent-memory/actions/workflows/tests.yml)
+
+Local BM25 recall over the files your agent already trusts, with line citations and a check that each source still matches what was indexed.
+
+**Status: alpha.** The CLI, Python API, and index schema may still change before 1.0.
+
+Most agent memory failures are not failures of semantic search.
+They are failures of trust: stale state, missing provenance, private data captured by default, and memory overriding the source of truth.
+
+Boring Agent Memory indexes the docs, skills, runbooks, bug logs, and ADRs you choose with SQLite FTS5.
+It returns source paths and snippets, and your agent reads the cited file before it acts.
+It needs no hosted service, embedding API, vector database, model download, or account.
+
+## Install
+
+```bash
+python -m pip install boring-agent-memory
+```
+
+It needs Python 3.11 or newer.
+
+## Try It
+
+```bash
+mkdir notes
+printf '# Deploys\n\nRoll back database migrations within 15 minutes.\n' > notes/deploys.md
+
+bam build --include notes
+bam query "roll back migrations"
+```
+
+```text
+deploys.md  score=-3e-06
+  /path/to/notes/deploys.md
+  # Deploys
+
+[Roll] [back] database [migrations] within 15 minutes.
+```
+
+Now change the file and check whether the index still matches it:
+
+```bash
+printf '# Deploys\n\nRoll back within 30 minutes.\n' > notes/deploys.md
+
+bam inspect notes/deploys.md
+bam update --include notes
+```
+
+`bam inspect` reports `content_hash_match: False` until `bam update` picks up the edit.
+
+## Use Your Own Files
+
+Point a config at the files you trust and save it as `memory.yaml`:
+
+```yaml
+index_path: ~/.bam/memory.db
+source_type: canonical_file
+workspace: ~/project/app
+
+include:
+  - ~/agent/skills
+  - ~/project/*/docs
+
+exclude:
+  - "**/secrets/**"
+```
+
+```bash
+bam build --config memory.yaml --json
+bam update --config memory.yaml --dry-run --json
+bam update --config memory.yaml --json
+
+bam --db ~/.bam/memory.db query "rollback policy" --limit 5 --json
+```
+
+A database that does not exist is an error, so a mistyped path cannot look like an empty memory.
+
+## Use It From An Agent
+
+```python
+from boring_agent_memory import memory_query
+
+results = memory_query(
+    "rollback policy for database migrations",
+    limit=5,
+    source_type="canonical_file",
+    db_path="~/.bam/memory.db",
+)
+
+for result in results:
+    print(result.citation)
+    print(result.snippet)
+```
+
+Other processes can use `bam serve --stdio`, which speaks JSON lines. See the [CLI reference](https://github.com/hskl18/boring-agent-memory/blob/main/docs/cli.md).
+
+Agent instructions to copy are in [docs/agent-prompt.md](https://github.com/hskl18/boring-agent-memory/blob/main/docs/agent-prompt.md), with setups for [Claude Code](https://github.com/hskl18/boring-agent-memory/blob/main/examples/claude_code.md), [Codex](https://github.com/hskl18/boring-agent-memory/blob/main/examples/codex.md), and [Hermes](https://github.com/hskl18/boring-agent-memory/blob/main/docs/hermes-integration.md).
+
+## Evidence
+
+On Benchmark v2's 12 synthetic queries, chunked BM25 finds the right lines first every time, while whole-document BM25 finds the right file 91% of the time and never the right lines.
+These are deterministic fixture results, not production traffic or a broad semantic-memory claim.
+See [Benchmark v2](https://github.com/hskl18/boring-agent-memory/blob/main/docs/benchmark-v2.md) and [why BM25 comes first](https://github.com/hskl18/boring-agent-memory/blob/main/docs/canonical-first-memory.md#why-bm25-first).
+
+## What It Is Not
+
+- Not a chatbot brain or an auto-capture memory system. It indexes only paths you name.
+- Not a replacement for semantic search over vague queries.
+- Not an authority over current files. Canonical files come first, BM25 recall second, model memory last.
+- Not a hosted service or a vector database.
+
+## Privacy
+
+Secret-bearing paths are skipped and common secret patterns are redacted before indexing, but these are guardrails, not a formal secret scanner.
+Read the [privacy model](https://github.com/hskl18/boring-agent-memory/blob/main/docs/privacy-model.md) before choosing what to index.
+
+## Documentation
+
+- [CLI reference](https://github.com/hskl18/boring-agent-memory/blob/main/docs/cli.md)
+- [Configuration](https://github.com/hskl18/boring-agent-memory/blob/main/docs/configuration.md)
+- [Python API](https://github.com/hskl18/boring-agent-memory/blob/main/docs/python-api.md)
+- [Architecture](https://github.com/hskl18/boring-agent-memory/blob/main/docs/architecture.md)
+- [Comparison with other memory tools](https://github.com/hskl18/boring-agent-memory/blob/main/docs/comparison.md)
+- [Status and known limits](https://github.com/hskl18/boring-agent-memory/blob/main/docs/status-and-gaps.md)
+- [Roadmap](https://github.com/hskl18/boring-agent-memory/blob/main/docs/roadmap.md)
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/hskl18/boring-agent-memory/blob/main/CONTRIBUTING.md), and read [SECURITY.md](https://github.com/hskl18/boring-agent-memory/blob/main/SECURITY.md) before sharing logs, configs, or memory fixtures.
+
+## License
+
+MIT

boring_agent_memory-0.2.2.dist-info/RECORD

@@ -0,0 +1,22 @@
+boring_agent_memory/__init__.py,sha256=BpzIw7PhQE0f_3mDCSvqfwW4cY8aX9gGvOyRGzhRdiY,277
+boring_agent_memory/api.py,sha256=fnNirQFK1L_bXRPvzgJfvogVTymXC_FFVm3BeyFpZAk,543
+boring_agent_memory/benchmark.py,sha256=EnyvZqIAzTQX7Ik09Y1001_B2A4meA6WjbcbFswqbQc,18377
+boring_agent_memory/canonical.py,sha256=dibyz1-vQFt41hqPRtf2ovsEEmNe6K20hSDhiQG54dU,2260
+boring_agent_memory/chunking.py,sha256=qIDlFbl-eDtD0GauzT9AeIiCNuYL6Vj_bRX-iDjJcmM,13514
+boring_agent_memory/cli.py,sha256=pV4ylAVBKGU9W6wdQcm3pyYw5L7_AOp3QIauydKSvlc,12690
+boring_agent_memory/config.py,sha256=m158Ib3l0u9gsE3w7iiuhrqdcYafRokeDPQkJP6f698,5404
+boring_agent_memory/embeddings.py,sha256=bUicUeA6JZv5EVYNB92HJJiu5bj84AGxFjOsKYHR-F4,9234
+boring_agent_memory/eval.py,sha256=WlVLLkiAHUBcuqOW4phXykCb8Y_QnCysmbeALsJOJVE,9865
+boring_agent_memory/index.py,sha256=6cR7gDpxCvqdn9owFv30TMXLMOcJj95_B_wQ2kQLaEs,15076
+boring_agent_memory/ingest.py,sha256=zl5B-rC81Mf1uk2C979tGJEQfKU8Jbd7_JTh7L4Shcs,4880
+boring_agent_memory/privacy.py,sha256=9tz-xvK5FhOes-DHHbw0cu1tq5Px_0NygT8AKDwV7gg,2203
+boring_agent_memory/query.py,sha256=uSkdj_wMJB2q__NrUQPbIhMCY9XiRyTdtINsCpcxVQU,6530
+boring_agent_memory/schema.py,sha256=DtTDCwt0eSrW7qUPIYMQqY5LRLQN972dy6RpdfXxOm8,7084
+boring_agent_memory/server.py,sha256=wEFzrKpyzMxmjcQ4RKzI-JABsl99WAYhHnadUVUi8co,1233
+boring_agent_memory/snippets.py,sha256=CKt5K3Kd-xXw78A0kl9WeyB9EAkT097AN0QguUzTNls,700
+boring_agent_memory-0.2.2.dist-info/licenses/LICENSE,sha256=fsBCl4I4dL3u79HotmimZWbp-MzULu1zMc6QDUVTFZE,1090
+boring_agent_memory-0.2.2.dist-info/METADATA,sha256=fnIFiWW6brD_0qdxiQ0vc6nfkMUBXERAma3qZ8b8NmU,6396
+boring_agent_memory-0.2.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+boring_agent_memory-0.2.2.dist-info/entry_points.txt,sha256=5YIq6c9FM_Jrtq5MmnM5YvOPd2nRC-ZNELtQSURUnfc,53
+boring_agent_memory-0.2.2.dist-info/top_level.txt,sha256=X-HqElxuI6jmSCU7bPww8yLIWHROF9aEwN7kjHZlkGo,20
+boring_agent_memory-0.2.2.dist-info/RECORD,,