perf: release GIL during I/O operations to prevent blocking

Addresses #21 - Release the Global Interpreter Lock during all
blocking operations to allow Python threads to run concurrently.

**Changes:**
- Wrapped all `runtime.block_on()` calls in `py.allow_threads()`
- Applies to: create(), add(), compact(), compaction_stats(),
  checkout(), search(), list()

**Benefits:**
- Python interpreter no longer freezes during operations
- Background threads (heartbeats, UI) remain responsive
- Critical for S3-backed stores (50-500ms+ latency)
- Critical for long-running compaction operations

**Pattern:**
```rust
py.allow_threads(|| {
    self.runtime
        .block_on(async_operation())
        .map_err(to_py_err)
})?
```

This ensures concurrent Python execution while Rust performs
expensive I/O and computation.

All tests pass (19 passed, 2 skipped).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jja725

python/src/lib.rs

@@ -113,6 +113,7 @@ impl Context {
     #[pyo3(signature = (uri, *, storage_options=None, compaction_config=None))]
     fn create(
         _cls: &Bound<'_, PyType>,
+        py: Python<'_>,
         uri: &str,
         storage_options: Option<&Bound<'_, PyDict>>,
         compaction_config: Option<&Bound<'_, PyDict>>,
@@ -124,9 +125,13 @@ impl Context {
             compaction: compaction_config_from_dict(compaction_config)?,
         };
 
-        let store = runtime
-            .block_on(ContextStore::open_with_options(uri, options))
-            .map_err(to_py_err)?;
+        // Release GIL during dataset initialization (may involve S3 operations)
+        let store = py.allow_threads(|| {
+            runtime
+                .block_on(ContextStore::open_with_options(uri, options))
+                .map_err(to_py_err)
+        })?;
+
         let run_id = new_run_id();
         Ok(Self {
             inner: RustContext::new(uri),
@@ -155,6 +160,7 @@ impl Context {
     #[pyo3(signature = (role, content, data_type = None))]
     fn add(
         &mut self,
+        py: Python<'_>,
         role: &str,
         content: &Bound<'_, PyAny>,
         data_type: Option<&str>,
@@ -191,9 +197,13 @@ impl Context {
             embedding: None,
         };
 
-        self.runtime
-            .block_on(self.store.add(std::slice::from_ref(&record)))
-            .map_err(to_py_err)?;
+        // Release GIL during storage write
+        py.allow_threads(|| {
+            self.runtime
+                .block_on(self.store.add(std::slice::from_ref(&record)))
+                .map_err(to_py_err)
+        })?;
+
         self.inner.add(role, &inner_content, data_type);
         Ok(())
     }
@@ -212,10 +222,13 @@ impl Context {
         }
     }
 
-    fn checkout(&mut self, version_id: u64) -> PyResult<()> {
-        self.runtime
-            .block_on(self.store.checkout(version_id))
-            .map_err(to_py_err)?;
+    fn checkout(&mut self, py: Python<'_>, version_id: u64) -> PyResult<()> {
+        // Release GIL during checkout operation
+        py.allow_threads(|| {
+            self.runtime
+                .block_on(self.store.checkout(version_id))
+                .map_err(to_py_err)
+        })?;
         self.run_id = new_run_id();
         Ok(())
     }
@@ -227,10 +240,13 @@ impl Context {
         query: Vec<f32>,
         limit: Option<usize>,
     ) -> PyResult<Vec<PyObject>> {
-        let hits = self
-            .runtime
-            .block_on(self.store.search(&query, limit))
-            .map_err(to_py_err)?;
+        // Release GIL during vector search
+        let hits = py.allow_threads(|| {
+            self.runtime
+                .block_on(self.store.search(&query, limit))
+                .map_err(to_py_err)
+        })?;
+
         hits.into_iter()
             .map(|hit| search_hit_to_py(py, hit))
             .collect()
@@ -243,10 +259,13 @@ impl Context {
         limit: Option<usize>,
         offset: Option<usize>,
     ) -> PyResult<Vec<PyObject>> {
-        let records = self
-            .runtime
-            .block_on(self.store.list(limit, offset))
-            .map_err(to_py_err)?;
+        // Release GIL during data retrieval
+        let records = py.allow_threads(|| {
+            self.runtime
+                .block_on(self.store.list(limit, offset))
+                .map_err(to_py_err)
+        })?;
+
         records
             .into_iter()
             .map(|record| record_to_py(py, record))
@@ -260,6 +279,7 @@ impl Context {
         target_rows_per_fragment: Option<usize>,
         materialize_deletions: Option<bool>,
     ) -> PyResult<PyObject> {
+        // Prepare config before releasing GIL
         let config = if target_rows_per_fragment.is_some() || materialize_deletions.is_some() {
             let mut cfg = self.store.compaction_config.clone();
             if let Some(rows) = target_rows_per_fragment {
@@ -273,19 +293,23 @@ impl Context {
             None
         };
 
-        let metrics = self
-            .runtime
-            .block_on(self.store.compact(config))
-            .map_err(to_py_err)?;
+        // Release GIL during expensive compaction operation
+        let metrics = py.allow_threads(|| {
+            self.runtime
+                .block_on(self.store.compact(config))
+                .map_err(to_py_err)
+        })?;
 
         compaction_metrics_to_py(py, metrics)
     }
 
     fn compaction_stats(&self, py: Python<'_>) -> PyResult<PyObject> {
-        let stats = self
-            .runtime
-            .block_on(self.store.compaction_stats())
-            .map_err(to_py_err)?;
+        // Release GIL during stats query
+        let stats = py.allow_threads(|| {
+            self.runtime
+                .block_on(self.store.compaction_stats())
+                .map_err(to_py_err)
+        })?;
 
         compaction_stats_to_py(py, stats)
     }