Fixed api python and rust

Author: anaslimem

README.md

@@ -214,11 +214,15 @@ db.load("document.pdf", strategy="recursive")
 | `.delete_memory(id)` | Permanently removes a memory and updates all indexes. |
 | `.compact()` | Reclaims space by removing deleted entries from disk. |
 | `.checkpoint()` | Truncates the WAL and snapshots the current state for fast startup. |
+| `.export_replay(path)` | Exports current state to a replay log (NDJSON). |
+| `CortexaDB.replay(log_path, db_path)` | Rebuilds a database from a replay log. |
 
 ### Configuration Options
 When calling `CortexaDB.open()`, you can tune the behavior:
 - `sync`: `"strict"` (safest), `"async"` (fastest), or `"batch"` (balanced).
 - `max_entries`: Limits the total number of memories (triggers auto-eviction).
+- `max_bytes`: Limits total stored bytes (triggers auto-eviction).
+- `index_mode`: `"exact"`, `"hnsw"`, or an HNSW config dict.
 - `record`: Path to a log file for capturing the entire session for replay.
 
 ---

crates/cortexadb-py/cortexadb/client.py

@@ -153,7 +153,8 @@ def __init__(
         embedder: t.Optional[Embedder] = None,
         sync: str = "strict",
         max_entries: t.Optional[int] = None,
-        index_mode: str = "exact",
+        max_bytes: t.Optional[int] = None,
+        index_mode: t.Union[str, t.Dict[str, t.Any]] = "exact",
         _recorder: t.Optional[ReplayWriter] = None,
     ):
         self._embedder = embedder
@@ -164,6 +165,7 @@ def __init__(
                 dimension=dimension,
                 sync=sync,
                 max_entries=max_entries,
+                max_bytes=max_bytes,
                 index_mode=index_mode,
             )
         except Exception as e:
@@ -180,7 +182,8 @@ def open(
         embedder: t.Optional[Embedder] = None,
         sync: str = "strict",
         max_entries: t.Optional[int] = None,
-        index_mode: str = "exact",
+        max_bytes: t.Optional[int] = None,
+        index_mode: t.Union[str, t.Dict[str, t.Any]] = "exact",
         record: t.Optional[str] = None,
     ) -> "CortexaDB":
         """
@@ -196,6 +199,8 @@ def open(
                        inferred from ``embedder.dimension`` automatically.
             sync:      Write durability policy: ``"strict"`` (default),
                        ``"async"``, or ``"batch"``.
+            max_entries: Optional entry-count limit for automatic eviction.
+            max_bytes: Optional byte-size limit for automatic eviction.
             index_mode: Search index mode: ``"exact"`` (default) or ``"hnsw"``.
                          Can also be a dict with HNSW parameters.
             record:    Optional path to a replay log file. When set, every write
@@ -225,6 +230,7 @@ def open(
             embedder=embedder,
             sync=sync,
             max_entries=max_entries,
+            max_bytes=max_bytes,
             index_mode=index_mode,
             _recorder=recorder,
         )
@@ -311,6 +317,11 @@ def replay(
                     db._inner.checkpoint()
                 except Exception:
                     pass  # non-fatal on fresh DB
+            elif op == "compact":
+                try:
+                    db._inner.compact()
+                except Exception:
+                    pass  # non-fatal on fresh DB
 
         return db
 
@@ -680,20 +691,23 @@ def export_replay(self, log_path: str) -> None:
             while found < target and checked < target * 4:
                 try:
                     mem = self._inner.get(candidate)
-                    # Retrieve the stored embedding via ask with dimension probe
-                    hits = self._inner.ask_in_namespace(
-                        namespace=mem.namespace,
-                        embedding=mem.embedding
-                        if hasattr(mem, "embedding")
-                        else [0.0] * dim,
-                        top_k=1,
-                    )
+                    embedding = getattr(mem, "embedding", None)
+                    if not embedding:
+                        candidate += 1
+                        checked += 1
+                        continue
+                    content = getattr(mem, "content", b"")
+                    if isinstance(content, bytes):
+                        text = content.decode("utf-8", errors="replace")
+                    else:
+                        text = str(content)
+                    metadata = dict(mem.metadata) if hasattr(mem, "metadata") else None
                     writer.record_remember(
                         id=mem.id,
-                        text=mem.content if hasattr(mem, "content") else "",
-                        embedding=mem.embedding if hasattr(mem, "embedding") else [],
+                        text=text,
+                        embedding=embedding,
                         namespace=mem.namespace,
-                        metadata=None,
+                        metadata=metadata,
                     )
                     found += 1
                 except Exception:

crates/cortexadb-py/src/lib.rs

@@ -146,6 +146,7 @@ impl PyHit {
 /// Attributes:
 ///     id (int): Memory identifier.
 ///     namespace (str): Namespace this memory belongs to.
+///     embedding (list[float] | None): Stored embedding vector.
 ///     metadata (dict[str, str]): Key-value metadata.
 ///     created_at (int): Unix timestamp when the memory was created.
 ///     importance (float): Importance score.
@@ -163,6 +164,8 @@ struct PyMemory {
     importance: f32,
     #[pyo3(get)]
     content: Vec<u8>,
+    #[pyo3(get)]
+    embedding: Option<Vec<f32>>,
     metadata_inner: HashMap<String, String>,
 }
 
@@ -259,14 +262,15 @@ impl PyCortexaDB {
     ///         mismatches an existing database.
     #[staticmethod]
     #[pyo3(
-        text_signature = "(path, *, dimension, sync='strict', index_mode='exact', max_entries=None)"
+        text_signature = "(path, *, dimension, sync='strict', index_mode='exact', max_entries=None, max_bytes=None)"
     )]
     fn open(
         path: &str,
         dimension: usize,
         sync: String,
         index_mode: Bound<'_, PyAny>,
         max_entries: Option<usize>,
+        max_bytes: Option<u64>,
     ) -> PyResult<Self> {
         if dimension == 0 {
             return Err(CortexaDBConfigError::new_err("dimension must be > 0"));
@@ -294,7 +298,7 @@ impl PyCortexaDB {
             // few entries. Disabling checkpoint avoids WAL truncation on Drop;
             // the user can still call checkpoint() explicitly when safe.
             checkpoint_policy: CheckpointPolicy::Disabled,
-            capacity_policy: CapacityPolicy::new(max_entries, None),
+            capacity_policy: CapacityPolicy::new(max_entries, max_bytes),
             index_mode,
         };
 
@@ -457,6 +461,7 @@ impl PyCortexaDB {
             created_at: entry.created_at,
             importance: entry.importance,
             content: entry.content.clone(),
+            embedding: entry.embedding.clone(),
             metadata_inner: entry.metadata.clone(),
         })
     }