epochdb 0.1.0__tar.gz

epochdb-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeff
+
+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.

epochdb-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: epochdb
+Version: 0.1.0
+Summary: An agentic memory engine designed for lossless, tiered verbatim storage and multi-hop retrieval.
+Author: Jeff
+License: MIT License
+Project-URL: Homepage, https://github.com/jeff/epochdb
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyarrow
+Requires-Dist: hnswlib
+Dynamic: license-file
+
+# EpochDB
+
+**EpochDB** is an agentic memory engine designed for lossless, tiered verbatim storage and multi-hop retrieval.
+
+## Why
+I had this idea while playing with LMDB. I wanted to create a memory system that could store conversations in a hybrid way, using in-memory for the most recent conversations and on-disk for older conversations. So, in order to have immutable data, I decided to use Parquet files for the on-disk storage. 
+
+## Overview
+Traditional AI memory systems compress conversations through destructive summarization. EpochDB bypasses this constraint by storing "Unified Memory Atoms"—the raw text intrinsically paired with dense embeddings.
+
+EpochDB uses a tiered architecture reminiscent of CPU caching:
+1. **L1: Working Memory**: Sub-millisecond HNSW vector index in RAM.
+2. **L2: Historical Archive**: Cold storage in immutable, time-partitioned `.parquet` files via PyArrow.
+
+It uniquely handles multi-hop retrieval over time-partitioned data using a **Global Entity Index**.
+
+## How It Works
+See [`how_it_works.md`](how_it_works.md) for a detailed technical dive into the architecture.
+
+## Benchmarks & Examples
+See [`benchmark.md`](benchmark.md) for traces of EpochDB successfully integrated via `LangGraph`. Check out [`example_langgraph.py`](example_langgraph.py) for the source code.

epochdb-0.1.0/README.md

@@ -0,0 +1,21 @@
+# EpochDB
+
+**EpochDB** is an agentic memory engine designed for lossless, tiered verbatim storage and multi-hop retrieval.
+
+## Why
+I had this idea while playing with LMDB. I wanted to create a memory system that could store conversations in a hybrid way, using in-memory for the most recent conversations and on-disk for older conversations. So, in order to have immutable data, I decided to use Parquet files for the on-disk storage. 
+
+## Overview
+Traditional AI memory systems compress conversations through destructive summarization. EpochDB bypasses this constraint by storing "Unified Memory Atoms"—the raw text intrinsically paired with dense embeddings.
+
+EpochDB uses a tiered architecture reminiscent of CPU caching:
+1. **L1: Working Memory**: Sub-millisecond HNSW vector index in RAM.
+2. **L2: Historical Archive**: Cold storage in immutable, time-partitioned `.parquet` files via PyArrow.
+
+It uniquely handles multi-hop retrieval over time-partitioned data using a **Global Entity Index**.
+
+## How It Works
+See [`how_it_works.md`](how_it_works.md) for a detailed technical dive into the architecture.
+
+## Benchmarks & Examples
+See [`benchmark.md`](benchmark.md) for traces of EpochDB successfully integrated via `LangGraph`. Check out [`example_langgraph.py`](example_langgraph.py) for the source code.

epochdb-0.1.0/epochdb/__init__.py

@@ -0,0 +1,4 @@
+from .engine import EpochDB
+from .atom import UnifiedMemoryAtom
+
+__all__ = ["EpochDB", "UnifiedMemoryAtom"]

epochdb-0.1.0/epochdb/atom.py

@@ -0,0 +1,46 @@
+import uuid
+import time
+from dataclasses import dataclass, field
+from typing import Any, List, Tuple
+import numpy as np
+
+@dataclass
+class UnifiedMemoryAtom:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    payload: Any = None
+    embedding: np.ndarray = field(default_factory=lambda: np.array([]))
+    triples: List[Tuple[str, str, str]] = field(default_factory=list)
+    created_at: float = field(default_factory=time.time)
+    access_count: int = 0
+    epoch_id: str = "active"
+
+    def calculate_saliency(self) -> float:
+        """
+        S = R / (T + 1)
+        where R is access_count and T is time since creation in hours.
+        """
+        T_hours = (time.time() - self.created_at) / 3600.0
+        return self.access_count / (T_hours + 1.0)
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "payload": self.payload,
+            "embedding": self.embedding.tolist(),
+            "triples": self.triples,
+            "created_at": self.created_at,
+            "access_count": self.access_count,
+            "epoch_id": self.epoch_id
+        }
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(
+            id=data["id"],
+            payload=data["payload"],
+            embedding=np.array(data["embedding"], dtype=np.float32),
+            triples=[tuple(t) for t in data["triples"]],
+            created_at=data["created_at"],
+            access_count=data["access_count"],
+            epoch_id=data["epoch_id"]
+        )

epochdb-0.1.0/epochdb/cold_tier.py

@@ -0,0 +1,81 @@
+import os
+import pyarrow as pa
+import pyarrow.parquet as pq
+import numpy as np
+from typing import List, Dict
+from .atom import UnifiedMemoryAtom
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ColdTier:
+    """
+    L2 Historical Archive. Resides on Disk.
+    Uses Parquet format.
+    """
+    def __init__(self, storage_dir: str):
+        self.storage_dir = storage_dir
+        os.makedirs(self.storage_dir, exist_ok=True)
+    
+    def serialize_epoch(self, epoch_id: str, atoms: List[UnifiedMemoryAtom]):
+        """Flushes hot partition to Parquet blocks."""
+        if not atoms:
+            return
+            
+        file_path = os.path.join(self.storage_dir, f"epoch_{epoch_id}.parquet")
+        
+        ids = [a.id for a in atoms]
+        payloads = [str(a.payload) for a in atoms]
+        embeddings = [a.embedding.tolist() for a in atoms]
+        created_ats = [a.created_at for a in atoms]
+        access_counts = [a.access_count for a in atoms]
+        triples_str = [str(a.triples) for a in atoms]
+
+        table = pa.table({
+            "id": ids,
+            "payload": payloads,
+            "embedding": embeddings,
+            "triples": triples_str,
+            "created_at": created_ats,
+            "access_count": access_counts,
+            "epoch_id": [epoch_id] * len(atoms)
+        })
+        
+        pq.write_table(table, file_path)
+        logger.info(f"Serialized {len(atoms)} atoms to {file_path}")
+
+    def load_epoch(self, epoch_id: str) -> List[UnifiedMemoryAtom]:
+        file_path = os.path.join(self.storage_dir, f"epoch_{epoch_id}.parquet")
+        if not os.path.exists(file_path):
+            return []
+            
+        table = pq.read_table(file_path)
+        rows = table.to_pylist()
+        
+        atoms = []
+        import ast
+        for row in rows:
+            try:
+                triples = ast.literal_eval(row['triples'])
+            except:
+                triples = []
+                
+            atom = UnifiedMemoryAtom(
+                id=row['id'],
+                payload=row['payload'],
+                embedding=np.array(row['embedding'], dtype=np.float32),
+                triples=triples,
+                created_at=row['created_at'],
+                access_count=row['access_count'],
+                epoch_id=row['epoch_id']
+            )
+            atoms.append(atom)
+        return atoms
+
+    def get_all_epochs(self) -> List[str]:
+        epochs = []
+        for f in os.listdir(self.storage_dir):
+            if f.startswith("epoch_") and f.endswith(".parquet"):
+                epoch_id = f[len("epoch_"):-len(".parquet")]
+                epochs.append(epoch_id)
+        return epochs

epochdb-0.1.0/epochdb/engine.py

@@ -0,0 +1,132 @@
+import os
+import time
+import json
+import logging
+from typing import List, Optional, Dict
+import numpy as np
+
+from .atom import UnifiedMemoryAtom
+from .hot_tier import HotTier
+from .cold_tier import ColdTier
+from .transaction import WriteAheadLog, FileLock, MultiIndexTransaction
+from .retrieval import RetrievalManager
+
+logger = logging.getLogger(__name__)
+
+class EpochDB:
+    """The main client for the Agentic Memory Engine."""
+    
+    def __init__(self, storage_dir: str = "./.epochdb_data", dim: int = 384, epoch_duration_secs: int = 3600, saliency_threshold: float = 0.1):
+        self.storage_dir = os.path.abspath(storage_dir)
+        self.dim = dim
+        self.epoch_duration_secs = epoch_duration_secs
+        self.saliency_threshold = saliency_threshold
+        
+        os.makedirs(self.storage_dir, exist_ok=True)
+        
+        # Concurrency Lock
+        self.lock = FileLock(os.path.join(self.storage_dir, ".lock"))
+        self.lock.acquire()
+        
+        # WAL
+        self.wal = WriteAheadLog(os.path.join(self.storage_dir, "wal.jsonl"))
+
+        # Global Entity Index
+        self.global_kg_file = os.path.join(self.storage_dir, "global_kg.json")
+        self.global_kg: Dict[str, List[List[str]]] = {}
+        if os.path.exists(self.global_kg_file):
+            try:
+                with open(self.global_kg_file, "r") as f:
+                    self.global_kg = json.load(f)
+            except Exception as e:
+                logger.error(f"Failed to load global KG: {e}")
+        
+        # Epoch State
+        self.current_epoch_id = f"epoch_{int(time.time())}"
+        self.epoch_start_time = time.time()
+        
+        # Tiers
+        self.hot_tier = HotTier(dim=self.dim)
+        self.cold_tier = ColdTier(self.storage_dir)
+        
+        # Retrieval
+        # We pass self.global_kg explicitly to the retriever now
+        self.retriever = RetrievalManager(self.hot_tier, self.cold_tier, self.global_kg)
+
+    def _save_global_kg(self):
+        with open(self.global_kg_file, "w") as f:
+            json.dump(self.global_kg, f)
+
+    def add_memory(self, payload: any, embedding: np.ndarray, triples: List[tuple] = None) -> str:
+        """Agent adds a new memory atom."""
+        if triples is None:
+            triples = []
+            
+        atom = UnifiedMemoryAtom(
+            payload=payload,
+            embedding=embedding,
+            triples=triples,
+            epoch_id=self.current_epoch_id
+        )
+        
+        # ACID Multi-Index Transaction
+        with MultiIndexTransaction(self.wal, self.hot_tier) as tx:
+            tx.add(atom)
+
+        # Update Global Index
+        for subj, pred, obj in triples:
+            if subj not in self.global_kg: self.global_kg[subj] = []
+            if obj not in self.global_kg: self.global_kg[obj] = []
+            
+            # Subj/Obj -> [atom.id, epoch_id]
+            self.global_kg[subj].append([atom.id, self.current_epoch_id])
+            self.global_kg[obj].append([atom.id, self.current_epoch_id])
+
+        self._save_global_kg()
+            
+        self._check_epoch_expiry()
+        return atom.id
+
+    def recall(self, query_emb: np.ndarray, top_k: int = 5) -> List[UnifiedMemoryAtom]:
+        """Agent queries memory."""
+        results = self.retriever.search(query_emb, top_k=top_k)
+        self._check_epoch_expiry()
+        return results
+
+    def _check_epoch_expiry(self):
+        """Lifecycle Management: Hot -> Cold"""
+        if time.time() - self.epoch_start_time > self.epoch_duration_secs:
+            self._checkpoint()
+
+    def _checkpoint(self):
+        """Epoch Checkpoint: Flush to disk, clear memory."""
+        logger.info(f"Triggering Epoch Checkpoint for {self.current_epoch_id}")
+        
+        # Gather atoms
+        atoms = list(self.hot_tier.atoms.values())
+        
+        if atoms:
+            self.cold_tier.serialize_epoch(self.current_epoch_id, atoms)
+        
+        # Clear Hot Tier & WAL
+        self.hot_tier.clear()
+        self.wal.clear()
+        
+        # Start new Epoch
+        self.current_epoch_id = f"epoch_{int(time.time())}"
+        self.epoch_start_time = time.time()
+
+    def force_checkpoint(self):
+        """Manually trigger checkpoint for testing."""
+        self._checkpoint()
+
+    def close(self):
+        self._save_global_kg()
+        self.wal.close()
+        self.lock.release()
+
+    def __del__(self):
+        try:
+            self.lock.release()
+        except:
+            pass

epochdb-0.1.0/epochdb/hot_tier.py

@@ -0,0 +1,72 @@
+import hnswlib
+import numpy as np
+import logging
+from typing import Dict, List, Optional
+from .atom import UnifiedMemoryAtom
+
+logger = logging.getLogger(__name__)
+
+class HotTier:
+    """
+    L1 Working Memory. Resides in RAM.
+    Houses Active Partition, vector index. (Global KG is now in engine).
+    """
+    def __init__(self, dim: int, max_elements: int = 10000):
+        self.dim = dim
+        self.max_elements = max_elements
+        
+        # HNSW Index for Vectors
+        self.vector_index = hnswlib.Index(space='cosine', dim=self.dim)
+        self.vector_index.init_index(max_elements=max_elements, ef_construction=200, M=16)
+        
+        # Atom storage: id -> UnifiedMemoryAtom
+        self.atoms: Dict[str, UnifiedMemoryAtom] = {}
+
+        # map string uuid to integer for hnsw
+        self.uuid_to_int = {}
+        self.int_to_uuid = {}
+        self._next_int_id = 0
+
+    def _add_atom(self, atom: UnifiedMemoryAtom):
+        """Internal method called by MIT transaction."""
+        if atom.id in self.atoms:
+            return  # Already exists
+
+        int_id = self._next_int_id
+        self.uuid_to_int[atom.id] = int_id
+        self.int_to_uuid[int_id] = atom.id
+        self._next_int_id += 1
+        
+        # 1. Add to Vector space
+        if atom.embedding is not None and len(atom.embedding) == self.dim:
+            self.vector_index.add_items([atom.embedding], [int_id])
+        else:
+            logger.warning(f"Atom {atom.id} has no valid embedding for dim {self.dim}.")
+        
+        # 3. Store payload
+        self.atoms[atom.id] = atom
+
+    def query_vector(self, query_emb: np.ndarray, top_k: int = 5) -> List[UnifiedMemoryAtom]:
+        if len(self.atoms) == 0:
+            return []
+        
+        actual_k = min(top_k, len(self.atoms))
+        # knn_query returns (labels, distances)
+        labels, distances = self.vector_index.knn_query([query_emb], k=actual_k)
+        
+        results = []
+        for int_lbl in labels[0]:
+            if int_lbl in self.int_to_uuid:
+                uuid_str = self.int_to_uuid[int_lbl]
+                results.append(self.atoms[uuid_str])
+                
+        return results
+        
+    def clear(self):
+        """Called upon Epoch Expiry after serialization."""
+        self.atoms.clear()
+        self.uuid_to_int.clear()
+        self.int_to_uuid.clear()
+        self._next_int_id = 0
+        self.vector_index = hnswlib.Index(space='cosine', dim=self.dim)
+        self.vector_index.init_index(max_elements=self.max_elements, ef_construction=200, M=16)

epochdb-0.1.0/epochdb/retrieval.py

@@ -0,0 +1,88 @@
+import numpy as np
+from typing import List, Dict, Set
+from .atom import UnifiedMemoryAtom
+from .hot_tier import HotTier
+from .cold_tier import ColdTier
+import logging
+
+logger = logging.getLogger(__name__)
+
+class RetrievalManager:
+    """Multi-stage retrieval process with Global KG."""
+    def __init__(self, hot_tier: HotTier, cold_tier: ColdTier, global_kg: Dict[str, List[List[str]]]):
+        self.hot_tier = hot_tier
+        self.cold_tier = cold_tier
+        self.global_kg = global_kg
+        
+    def _fetch_atom_by_id(self, atom_id: str, epoch_id: str) -> UnifiedMemoryAtom:
+        # Check Hot Tier
+        if atom_id in self.hot_tier.atoms:
+            return self.hot_tier.atoms[atom_id]
+        
+        # Check Cold Tier targeted by epoch
+        # epoch_id might be "epoch_X" but load_epoch expects X
+        epoch_str = epoch_id.replace("epoch_", "")
+        atoms = self.cold_tier.load_epoch(epoch_str)
+        for a in atoms:
+            if a.id == atom_id:
+                return a
+        return None
+
+    def search(self, query_emb: np.ndarray, top_k: int = 5, expand_hops: int = 1) -> List[UnifiedMemoryAtom]:
+        candidates: Dict[str, UnifiedMemoryAtom] = {}
+
+        # 1. Semantic Hook (Hot Tier)
+        hot_hits = self.hot_tier.query_vector(query_emb, top_k=top_k)
+        for atom in hot_hits:
+            candidates[atom.id] = atom
+
+        # Cold tier Semantic Hook
+        epochs = self.cold_tier.get_all_epochs()
+        for epoch in epochs:
+            cold_atoms = self.cold_tier.load_epoch(epoch)
+            if cold_atoms:
+                embeddings = np.array([a.embedding for a in cold_atoms])
+                norms = np.linalg.norm(embeddings, axis=1) * np.linalg.norm(query_emb)
+                norms = np.where(norms == 0, 1e-10, norms)
+                dots = np.dot(embeddings, query_emb)
+                sims = dots / norms
+                
+                best_idx = np.argsort(sims)[-top_k:][::-1]
+                for idx in best_idx:
+                    if sims[idx] > 0.0:
+                        atom = cold_atoms[idx]
+                        candidates[atom.id] = atom
+
+        # 2. Relational Expansion (Global KG)
+        if expand_hops > 0:
+            expansion_set = set(candidates.keys())
+            for _ in range(expand_hops):
+                new_neighbors = set()
+                # Step B: Identify Entities
+                for a_id in expansion_set:
+                    atom = candidates.get(a_id)
+                    if not atom: continue
+                    entities = set()
+                    for subj, pred, obj in atom.triples:
+                        entities.add(subj)
+                        entities.add(obj)
+                    
+                    # Step C: Query KG for neighbors
+                    for ent in entities:
+                        if ent in self.global_kg:
+                            for neighbor_atom_id, epoch_id in self.global_kg[ent]:
+                                if neighbor_atom_id not in candidates:
+                                    # Step D: Targeted Fetch
+                                    n_atom = self._fetch_atom_by_id(neighbor_atom_id, epoch_id)
+                                    if n_atom:
+                                        new_neighbors.add(n_atom.id)
+                                        candidates[n_atom.id] = n_atom
+                expansion_set = new_neighbors
+
+        # 3. Temporal Re-ranking and Update Access
+        results = list(candidates.values())
+        for r in results:
+            r.access_count += 1
+            
+        results.sort(key=lambda x: x.calculate_saliency(), reverse=True)
+        return results[:top_k * 2]

epochdb-0.1.0/epochdb/transaction.py

@@ -0,0 +1,73 @@
+import os
+import json
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class FileLock:
+    """A simple file-based lock to prevent concurrent epochdb intances from writing."""
+    def __init__(self, lock_path: str):
+        self.lock_path = lock_path
+
+    def acquire(self):
+        if os.path.exists(self.lock_path):
+            raise RuntimeError(f"Database is locked by another process: {self.lock_path}")
+        with open(self.lock_path, "w") as f:
+            f.write(str(os.getpid()))
+
+    def release(self):
+        if os.path.exists(self.lock_path):
+            os.remove(self.lock_path)
+
+
+class WriteAheadLog:
+    """Append-only JSONL log for crash recovery."""
+    def __init__(self, wal_path: str):
+        self.wal_path = wal_path
+        self._file = open(self.wal_path, "a")
+
+    def append(self, operation: str, data: Dict[str, Any]):
+        record = json.dumps({"op": operation, "data": data})
+        self._file.write(record + "\n")
+        self._file.flush()
+        os.fsync(self._file.fileno())
+
+    def close(self):
+        self._file.close()
+
+    def clear(self):
+        """Called upon successful Epoch Checkpoint."""
+        self._file.close()
+        open(self.wal_path, "w").close()
+        self._file = open(self.wal_path, "a")
+
+
+class MultiIndexTransaction:
+    """
+    Context manager to ensure an atom is written to the WAL,
+    the Vector Index, and the Knowledge Graph atomically.
+    """
+    def __init__(self, wal: WriteAheadLog, hot_tier):
+        self.wal = wal
+        self.hot_tier = hot_tier
+        self.pending_atoms = []
+    
+    def __enter__(self):
+        self.pending_atoms = []
+        return self
+
+    def add(self, atom):
+        self.pending_atoms.append(atom)
+        self.wal.append("ADD", atom.to_dict())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            logger.error(f"Transaction failed, rolling back. Reason: {exc_val}")
+            self.wal.append("ROLLBACK", {})
+            return False 
+        
+        for atom in self.pending_atoms:
+            self.hot_tier._add_atom(atom)
+        self.wal.append("COMMIT", {})
+        return True

epochdb-0.1.0/epochdb.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: epochdb
+Version: 0.1.0
+Summary: An agentic memory engine designed for lossless, tiered verbatim storage and multi-hop retrieval.
+Author: Jeff
+License: MIT License
+Project-URL: Homepage, https://github.com/jeff/epochdb
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyarrow
+Requires-Dist: hnswlib
+Dynamic: license-file
+
+# EpochDB
+
+**EpochDB** is an agentic memory engine designed for lossless, tiered verbatim storage and multi-hop retrieval.
+
+## Why
+I had this idea while playing with LMDB. I wanted to create a memory system that could store conversations in a hybrid way, using in-memory for the most recent conversations and on-disk for older conversations. So, in order to have immutable data, I decided to use Parquet files for the on-disk storage. 
+
+## Overview
+Traditional AI memory systems compress conversations through destructive summarization. EpochDB bypasses this constraint by storing "Unified Memory Atoms"—the raw text intrinsically paired with dense embeddings.
+
+EpochDB uses a tiered architecture reminiscent of CPU caching:
+1. **L1: Working Memory**: Sub-millisecond HNSW vector index in RAM.
+2. **L2: Historical Archive**: Cold storage in immutable, time-partitioned `.parquet` files via PyArrow.
+
+It uniquely handles multi-hop retrieval over time-partitioned data using a **Global Entity Index**.
+
+## How It Works
+See [`how_it_works.md`](how_it_works.md) for a detailed technical dive into the architecture.
+
+## Benchmarks & Examples
+See [`benchmark.md`](benchmark.md) for traces of EpochDB successfully integrated via `LangGraph`. Check out [`example_langgraph.py`](example_langgraph.py) for the source code.

epochdb-0.1.0/epochdb.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+epochdb/__init__.py
+epochdb/atom.py
+epochdb/cold_tier.py
+epochdb/engine.py
+epochdb/hot_tier.py
+epochdb/retrieval.py
+epochdb/transaction.py
+epochdb.egg-info/PKG-INFO
+epochdb.egg-info/SOURCES.txt
+epochdb.egg-info/dependency_links.txt
+epochdb.egg-info/requires.txt
+epochdb.egg-info/top_level.txt

epochdb-0.1.0/epochdb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

epochdb-0.1.0/epochdb.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+pyarrow
+hnswlib

epochdb-0.1.0/epochdb.egg-info/top_level.txt

@@ -0,0 +1 @@
+epochdb

epochdb-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "epochdb"
+version = "0.1.0"
+description = "An agentic memory engine designed for lossless, tiered verbatim storage and multi-hop retrieval."
+readme = "README.md"
+license = { text = "MIT License" }
+authors = [
+  { name = "Jeff" }
+]
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "numpy",
+    "pyarrow",
+    "hnswlib"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jeff/epochdb"

epochdb-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+