maggraph 0.3.0__tar.gz → 0.4.0__tar.gz

{maggraph-0.3.0 → maggraph-0.4.0}/Cargo.lock

@@ -839,7 +839,7 @@ checksum = "113b30b4cd05f7c06868fdb2854f66a7b9fece9a48425351cd532e810d74024f"
 
 [[package]]
 name = "maggraph"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "axum",
  "chrono",
@@ -862,7 +862,7 @@ dependencies = [
 
 [[package]]
 name = "maggraph-cli"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "assert_cmd",
  "axum",

{maggraph-0.3.0 → maggraph-0.4.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["maggraph"]
 resolver = "2"
 
 [workspace.package]
-version = "0.3.0"
+version = "0.4.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/AlexMercedCoder/MagGraph"

{maggraph-0.3.0 → maggraph-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maggraph
-Version: 0.3.0
+Version: 0.4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -205,6 +205,7 @@ maggraph sync pull
 | `GraphIndex.list_nodes()` | All node ids (sorted) |
 | `GraphIndex.read_node(id)` | `Node` with metadata + body |
 | `GraphIndex.search(...)` | Structured search over ids, types, tags, frontmatter, links, body, and recency |
+| `GraphIndex.hybrid_search(...)` | Explainable lexical + graph + recency + optional semantic retrieval with temporal/project filters |
 | `GraphIndex.backlinks(id)` | Node ids that link to `id` |
 | `GraphIndex.changed_since(unix)` | Files modified after a Unix timestamp |
 | `GraphIndex.update_file(path)` | Refresh one changed markdown file in the index |
@@ -214,6 +215,7 @@ maggraph sync pull
 | `GraphIndex.traverse_async(...)` | Async version |
 | `GraphIndex.create_node(...)` | Write new node to disk + index |
 | `GraphIndex.create_memory_node(...)` | Create typed memory nodes (`preference`, `project_fact`, `decision`, `task`, `session_summary`, `bookmark`, `tool_failure`) |
+| `GraphIndex.apply_memory_batch(...)` | Preview or apply reviewed update/suppress/unsuppress/merge operations as one rollback-capable batch |
 | `GraphIndex.update_node(id, body)` | Update body on disk |
 | `GraphIndex.delete_node(id)` | Delete node from disk + index |
 | `GraphIndex.suppress_node(id)` / `unsuppress_node(id)` | Mark/unmark stale or duplicate nodes |

{maggraph-0.3.0 → maggraph-0.4.0}/README.md

@@ -168,6 +168,7 @@ maggraph sync pull
 | `GraphIndex.list_nodes()` | All node ids (sorted) |
 | `GraphIndex.read_node(id)` | `Node` with metadata + body |
 | `GraphIndex.search(...)` | Structured search over ids, types, tags, frontmatter, links, body, and recency |
+| `GraphIndex.hybrid_search(...)` | Explainable lexical + graph + recency + optional semantic retrieval with temporal/project filters |
 | `GraphIndex.backlinks(id)` | Node ids that link to `id` |
 | `GraphIndex.changed_since(unix)` | Files modified after a Unix timestamp |
 | `GraphIndex.update_file(path)` | Refresh one changed markdown file in the index |
@@ -177,6 +178,7 @@ maggraph sync pull
 | `GraphIndex.traverse_async(...)` | Async version |
 | `GraphIndex.create_node(...)` | Write new node to disk + index |
 | `GraphIndex.create_memory_node(...)` | Create typed memory nodes (`preference`, `project_fact`, `decision`, `task`, `session_summary`, `bookmark`, `tool_failure`) |
+| `GraphIndex.apply_memory_batch(...)` | Preview or apply reviewed update/suppress/unsuppress/merge operations as one rollback-capable batch |
 | `GraphIndex.update_node(id, body)` | Update body on disk |
 | `GraphIndex.delete_node(id)` | Delete node from disk + index |
 | `GraphIndex.suppress_node(id)` / `unsuppress_node(id)` | Mark/unmark stale or duplicate nodes |

{maggraph-0.3.0 → maggraph-0.4.0}/maggraph/__init__.pyi

@@ -9,6 +9,17 @@ class SearchResult(TypedDict):
     summary: str
     modified_unix: Optional[int]
 
+class HybridSearchResult(TypedDict):
+    id: str
+    type: str
+    relative_path: str
+    score: float
+    signals: dict[str, float]
+    reasons: list[str]
+    summary: str
+    modified_unix: Optional[int]
+    canonical_id: str
+
 class GraphChange(TypedDict):
     id: str
     relative_path: str
@@ -25,6 +36,12 @@ class RecallBundle(TypedDict):
     relevance_reason: str
     markdown: str
 
+class MemoryBatchResult(TypedDict, total=False):
+    ok: bool
+    preview: bool
+    operations: int
+    applied: list[str]
+
 class MagGraphError(Exception): ...
 
 class ResolvedConfig:
@@ -54,6 +71,20 @@ class GraphIndex:
         limit: int = 50,
         modified_since_unix: int | None = None,
     ) -> list[SearchResult]: ...
+    def hybrid_search(
+        self,
+        query: str = "",
+        node_types: list[str] | None = None,
+        tags: list[str] | None = None,
+        project: str | None = None,
+        seed_ids: list[str] | None = None,
+        semantic_scores: dict[str, float] | None = None,
+        include_suppressed: bool = False,
+        include_superseded: bool = False,
+        limit: int = 20,
+        as_of_unix: int | None = None,
+        recency_half_life_days: float = 30.0,
+    ) -> list[HybridSearchResult]: ...
     def backlinks(self, node_id: str) -> list[str]: ...
     def changed_since(self, since_unix: int) -> list[GraphChange]: ...
     def update_file(self, path: str) -> Optional[str]: ...
@@ -79,12 +110,25 @@ class GraphIndex:
         ],
         body: str = "",
         links: list[str] | None = None,
+        project: str | None = None,
+        source_task: str | None = None,
+        source_session: str | None = None,
+        source_tool: str | None = None,
+        extraction_method: str | None = None,
+        confidence: float | None = None,
+        valid_from: str | None = None,
+        valid_until: str | None = None,
+        supersedes: str | None = None,
+        canonical_id: str | None = None,
     ) -> Node: ...
     def update_node(self, node_id: str, body: str) -> None: ...
     def delete_node(self, node_id: str) -> None: ...
     def suppress_node(self, node_id: str, reason: str | None = None) -> None: ...
     def unsuppress_node(self, node_id: str) -> None: ...
     def merge_nodes(self, target_id: str, source_id: str) -> None: ...
+    def apply_memory_batch(
+        self, operations: list[dict[str, str]], preview: bool = False
+    ) -> MemoryBatchResult: ...
     def recall_bundle(
         self, node_id: str, reason: str = "", body_chars: int = 1200
     ) -> RecallBundle: ...

{maggraph-0.3.0 → maggraph-0.4.0}/maggraph/benches/index_scale.rs

@@ -2,7 +2,9 @@ use std::env;
 use std::fs;
 use std::time::{Duration, Instant};
 
-use maggraph::{GraphIndex, QueryOptions};
+use std::collections::HashMap;
+
+use maggraph::{GraphIndex, HybridQueryOptions, QueryOptions};
 use tempfile::TempDir;
 
 fn sizes() -> Vec<usize> {
@@ -44,7 +46,7 @@ fn timed<T>(operation: impl FnOnce() -> T) -> (T, Duration) {
 
 fn main() {
     println!("MagGraph index scale benchmark");
-    println!("nodes,open_ms,search_ms,backlinks_ms,recall_us,update_us");
+    println!("nodes,open_ms,search_ms,hybrid_ms,backlinks_ms,recall_us,update_us");
 
     for count in sizes() {
         let temp = TempDir::new().expect("temp dir");
@@ -60,6 +62,17 @@ fn main() {
         };
         let (results, search) = timed(|| index.search(&options).expect("search"));
         assert!(!results.is_empty());
+        let hybrid_options = HybridQueryOptions {
+            text: Some("needle group 42".into()),
+            tags: vec!["benchmark".into()],
+            seed_ids: vec!["node_000042".into()],
+            semantic_scores: HashMap::from([("node_000142".into(), 0.9)]),
+            limit: 50,
+            ..HybridQueryOptions::default()
+        };
+        let (hybrid_results, hybrid) =
+            timed(|| index.hybrid_search(&hybrid_options).expect("hybrid search"));
+        assert!(!hybrid_results.is_empty());
 
         let (_, backlinks) = timed(|| index.backlinks("node_000042").expect("backlinks"));
         let (_, recall) = timed(|| {
@@ -74,9 +87,10 @@ fn main() {
         });
 
         println!(
-            "{count},{:.3},{:.3},{:.3},{:.3},{:.3}",
+            "{count},{:.3},{:.3},{:.3},{:.3},{:.3},{:.3}",
             open.as_secs_f64() * 1_000.0,
             search.as_secs_f64() * 1_000.0,
+            hybrid.as_secs_f64() * 1_000.0,
             backlinks.as_secs_f64() * 1_000.0,
             recall.as_secs_f64() * 1_000_000.0,
             update.as_secs_f64() * 1_000_000.0,

maggraph-0.4.0/maggraph/src/batch.rs

@@ -0,0 +1,379 @@
+//! Transaction-like reviewed memory operations with rollback on failure.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::error::{MagGraphError, Result};
+use crate::index::GraphIndex;
+use crate::node::Node;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MemoryBatchOperation {
+    UpdateBody {
+        id: String,
+        body: String,
+    },
+    Suppress {
+        id: String,
+        reason: Option<String>,
+    },
+    Unsuppress {
+        id: String,
+    },
+    Merge {
+        target_id: String,
+        source_id: String,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MemoryBatchResult {
+    pub applied: Vec<String>,
+}
+
+const JOURNAL_VERSION: u8 = 1;
+const TRANSACTIONS_DIR: &str = "transactions";
+
+#[derive(Debug, Serialize, Deserialize)]
+struct BatchJournal {
+    version: u8,
+    snapshots: Vec<JournalSnapshot>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct JournalSnapshot {
+    relative_path: PathBuf,
+    backup: PathBuf,
+}
+
+pub fn apply_memory_batch(
+    index: &mut GraphIndex,
+    operations: &[MemoryBatchOperation],
+) -> Result<MemoryBatchResult> {
+    validate_memory_batch(index, operations)?;
+    let snapshots = snapshots(index, operations)?;
+    let journal = prepare_journal(index.root_path(), &snapshots)?;
+    let mut applied = Vec::new();
+    for operation in operations {
+        let result = apply_one(index, operation);
+        match result {
+            Ok(label) => applied.push(label),
+            Err(error) => {
+                restore_journal(index.root_path(), &journal)?;
+                index.rescan()?;
+                return Err(error);
+            }
+        }
+    }
+    fs::remove_dir_all(&journal).map_err(|error| {
+        MagGraphError::Index(format!("failed to remove completed batch journal: {error}"))
+    })?;
+    Ok(MemoryBatchResult { applied })
+}
+
+/// Restore any prepared batch that did not reach journal cleanup before shutdown.
+pub(crate) fn recover_incomplete_batches(root: &Path) -> Result<usize> {
+    let transactions = transaction_root(root);
+    if !transactions.exists() {
+        return Ok(0);
+    }
+    let mut recovered = 0;
+    for entry in fs::read_dir(&transactions).map_err(|error| {
+        MagGraphError::Index(format!("failed to inspect batch journals: {error}"))
+    })? {
+        let path = entry
+            .map_err(|error| {
+                MagGraphError::Index(format!("failed to read batch journal: {error}"))
+            })?
+            .path();
+        if !path.is_dir() {
+            continue;
+        }
+        if path.join("manifest.toml").exists() {
+            restore_journal(root, &path)?;
+            recovered += 1;
+        } else {
+            fs::remove_dir_all(&path).map_err(|error| {
+                MagGraphError::Index(format!(
+                    "failed to remove unprepared batch journal: {error}"
+                ))
+            })?;
+        }
+    }
+    Ok(recovered)
+}
+
+pub fn validate_memory_batch(
+    index: &GraphIndex,
+    operations: &[MemoryBatchOperation],
+) -> Result<()> {
+    let mut removed = BTreeSet::new();
+    for operation in operations {
+        match operation {
+            MemoryBatchOperation::UpdateBody { id, .. }
+            | MemoryBatchOperation::Suppress { id, .. }
+            | MemoryBatchOperation::Unsuppress { id } => {
+                require_available(index, id, &removed)?;
+            }
+            MemoryBatchOperation::Merge {
+                target_id,
+                source_id,
+            } => {
+                if target_id == source_id {
+                    return Err(MagGraphError::Index(
+                        "cannot merge a node into itself".to_string(),
+                    ));
+                }
+                require_available(index, target_id, &removed)?;
+                require_available(index, source_id, &removed)?;
+                removed.insert(source_id.clone());
+            }
+        }
+    }
+    Ok(())
+}
+
+fn require_available(index: &GraphIndex, id: &str, removed: &BTreeSet<String>) -> Result<()> {
+    if removed.contains(id) || !index.contains(id) {
+        return Err(MagGraphError::NodeNotFound { id: id.to_string() });
+    }
+    Ok(())
+}
+
+fn snapshots(
+    index: &GraphIndex,
+    operations: &[MemoryBatchOperation],
+) -> Result<BTreeMap<String, Node>> {
+    let mut ids = BTreeSet::new();
+    for operation in operations {
+        match operation {
+            MemoryBatchOperation::UpdateBody { id, .. }
+            | MemoryBatchOperation::Suppress { id, .. }
+            | MemoryBatchOperation::Unsuppress { id } => {
+                ids.insert(id.clone());
+            }
+            MemoryBatchOperation::Merge {
+                target_id,
+                source_id,
+            } => {
+                ids.insert(target_id.clone());
+                ids.insert(source_id.clone());
+            }
+        }
+    }
+    ids.into_iter()
+        .map(|id| index.read_node(&id).map(|node| (id, node)))
+        .collect()
+}
+
+fn apply_one(index: &mut GraphIndex, operation: &MemoryBatchOperation) -> Result<String> {
+    match operation {
+        MemoryBatchOperation::UpdateBody { id, body } => {
+            let mut node = index.read_node(id)?;
+            node.body = body.clone();
+            index.update_node(node)?;
+            Ok(format!("update:{id}"))
+        }
+        MemoryBatchOperation::Suppress { id, reason } => {
+            index.suppress_node(id, reason.as_deref())?;
+            Ok(format!("suppress:{id}"))
+        }
+        MemoryBatchOperation::Unsuppress { id } => {
+            index.unsuppress_node(id)?;
+            Ok(format!("unsuppress:{id}"))
+        }
+        MemoryBatchOperation::Merge {
+            target_id,
+            source_id,
+        } => {
+            index.merge_nodes(target_id, source_id)?;
+            Ok(format!("merge:{source_id}->{target_id}"))
+        }
+    }
+}
+
+fn transaction_root(root: &Path) -> PathBuf {
+    root.join(crate::config::METADATA_DIR_NAME)
+        .join(TRANSACTIONS_DIR)
+}
+
+fn prepare_journal(root: &Path, snapshots: &BTreeMap<String, Node>) -> Result<PathBuf> {
+    let journal_dir = transaction_root(root).join(Uuid::new_v4().to_string());
+    let backup_dir = journal_dir.join("backups");
+    fs::create_dir_all(&backup_dir).map_err(|error| {
+        MagGraphError::Index(format!("failed to create batch journal: {error}"))
+    })?;
+    let mut journal = BatchJournal {
+        version: JOURNAL_VERSION,
+        snapshots: Vec::new(),
+    };
+    for (index, node) in snapshots.values().enumerate() {
+        crate::security::validate_relative_node_path(&node.relative_path)?;
+        let backup = PathBuf::from("backups").join(format!("{index:04}.md"));
+        sync_write(&journal_dir.join(&backup), node.to_markdown()?.as_bytes())?;
+        journal.snapshots.push(JournalSnapshot {
+            relative_path: node.relative_path.clone(),
+            backup,
+        });
+    }
+    let manifest = toml::to_string(&journal).map_err(|error| {
+        MagGraphError::Index(format!("failed to serialize batch journal: {error}"))
+    })?;
+    sync_write(&journal_dir.join("manifest.toml"), manifest.as_bytes())?;
+    Ok(journal_dir)
+}
+
+fn restore_journal(root: &Path, journal_dir: &Path) -> Result<()> {
+    let manifest_path = journal_dir.join("manifest.toml");
+    let manifest = fs::read_to_string(&manifest_path).map_err(|error| {
+        MagGraphError::Index(format!(
+            "failed to read batch journal {}: {error}",
+            manifest_path.display()
+        ))
+    })?;
+    let journal: BatchJournal = toml::from_str(&manifest)
+        .map_err(|error| MagGraphError::Index(format!("failed to parse batch journal: {error}")))?;
+    if journal.version != JOURNAL_VERSION {
+        return Err(MagGraphError::Index(format!(
+            "unsupported batch journal version {}",
+            journal.version
+        )));
+    }
+    for snapshot in journal.snapshots {
+        crate::security::validate_relative_node_path(&snapshot.relative_path)?;
+        crate::security::validate_relative_node_path(&snapshot.backup)?;
+        let contents = fs::read_to_string(journal_dir.join(&snapshot.backup)).map_err(|error| {
+            MagGraphError::Index(format!("failed to read batch backup: {error}"))
+        })?;
+        let (metadata, body) = crate::node::parse_markdown_node(&contents, &snapshot.relative_path)
+            .map_err(|message| MagGraphError::NodeParse {
+                path: snapshot.relative_path.clone(),
+                message,
+            })?;
+        Node {
+            metadata,
+            body,
+            relative_path: snapshot.relative_path,
+        }
+        .write_to(root)?;
+    }
+    fs::remove_dir_all(journal_dir).map_err(|error| {
+        MagGraphError::Index(format!("failed to clear recovered batch journal: {error}"))
+    })
+}
+
+fn sync_write(path: &Path, contents: &[u8]) -> Result<()> {
+    let mut file = File::create(path).map_err(|error| {
+        MagGraphError::Index(format!("failed to create {}: {error}", path.display()))
+    })?;
+    file.write_all(contents)
+        .and_then(|_| file.sync_all())
+        .map_err(|error| {
+            MagGraphError::Index(format!("failed to sync {}: {error}", path.display()))
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use tempfile::TempDir;
+
+    use super::*;
+
+    fn index() -> (TempDir, GraphIndex) {
+        let temp = TempDir::new().expect("tempdir");
+        for id in ["a", "b"] {
+            fs::write(
+                temp.path().join(format!("{id}.md")),
+                format!("---\nid: {id}\ntype: decision\n---\nBody {id}.\n"),
+            )
+            .expect("write node");
+        }
+        let index = GraphIndex::open(temp.path()).expect("open");
+        (temp, index)
+    }
+
+    #[test]
+    fn batch_applies_reviewed_operations() {
+        let (_temp, mut index) = index();
+        let result = apply_memory_batch(
+            &mut index,
+            &[
+                MemoryBatchOperation::UpdateBody {
+                    id: "a".to_string(),
+                    body: "Updated.".to_string(),
+                },
+                MemoryBatchOperation::Suppress {
+                    id: "b".to_string(),
+                    reason: Some("stale".to_string()),
+                },
+            ],
+        )
+        .expect("batch");
+
+        assert_eq!(result.applied, ["update:a", "suppress:b"]);
+        assert_eq!(index.read_node("a").unwrap().body, "Updated.\n");
+        assert!(crate::query::is_suppressed(&index.read_node("b").unwrap()));
+    }
+
+    #[test]
+    fn batch_prevalidation_prevents_partial_changes() {
+        let (_temp, mut index) = index();
+        let error = apply_memory_batch(
+            &mut index,
+            &[
+                MemoryBatchOperation::UpdateBody {
+                    id: "a".to_string(),
+                    body: "Must not persist.".to_string(),
+                },
+                MemoryBatchOperation::Suppress {
+                    id: "missing".to_string(),
+                    reason: None,
+                },
+            ],
+        )
+        .unwrap_err();
+
+        assert!(matches!(error, MagGraphError::NodeNotFound { .. }));
+        assert_eq!(index.read_node("a").unwrap().body, "Body a.\n");
+    }
+
+    #[test]
+    fn reopen_recovers_a_partially_applied_batch() {
+        let (temp, index) = index();
+        let snapshots = snapshots(
+            &index,
+            &[MemoryBatchOperation::Merge {
+                target_id: "a".to_string(),
+                source_id: "b".to_string(),
+            }],
+        )
+        .expect("snapshots");
+        let _journal = prepare_journal(temp.path(), &snapshots).expect("journal");
+
+        fs::write(
+            temp.path().join("a.md"),
+            "---\nid: a\ntype: decision\n---\nPartially updated.\n",
+        )
+        .expect("partial target");
+        fs::remove_file(temp.path().join("b.md")).expect("partial delete");
+
+        let reopened = GraphIndex::open(temp.path()).expect("recover and reopen");
+        assert_eq!(reopened.read_node("a").unwrap().body, "Body a.\n");
+        assert_eq!(reopened.read_node("b").unwrap().body, "Body b.\n");
+        assert!(
+            !transaction_root(temp.path()).exists()
+                || transaction_root(temp.path())
+                    .read_dir()
+                    .unwrap()
+                    .next()
+                    .is_none()
+        );
+    }
+}

{maggraph-0.3.0 → maggraph-0.4.0}/maggraph/src/index.rs

@@ -8,7 +8,9 @@ use walkdir::WalkDir;
 use crate::error::{MagGraphError, Result};
 use crate::graph::GraphAdjacency;
 use crate::node::{NewNode, Node, NodeMetadata};
-use crate::query::{changed_since, GraphChange, QueryOptions, SearchResult};
+use crate::query::{
+    changed_since, GraphChange, HybridQueryOptions, HybridSearchResult, QueryOptions, SearchResult,
+};
 use crate::recall::{recall_bundle, RecallBundle};
 use crate::security::validate_relative_node_path;
 use crate::sync::WritePolicy;
@@ -63,6 +65,8 @@ impl GraphIndex {
             )));
         }
 
+        crate::batch::recover_incomplete_batches(&root_path)?;
+
         let mut index = Self {
             root_path,
             by_id: HashMap::new(),
@@ -202,6 +206,11 @@ impl GraphIndex {
         crate::query::search_index(self, options)
     }
 
+    /// Explainable hybrid retrieval over lexical, graph, recency, and semantic signals.
+    pub fn hybrid_search(&self, options: &HybridQueryOptions) -> Result<Vec<HybridSearchResult>> {
+        crate::query::hybrid_search_index(self, options)
+    }
+
     /// Node ids that link to `id`.
     pub fn backlinks(&self, id: &str) -> Result<Vec<String>> {
         if !self.contains(id) {

{maggraph-0.3.0 → maggraph-0.4.0}/maggraph/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod agent;
+pub mod batch;
 pub mod config;
 pub mod error;
 pub mod graph;
@@ -20,6 +21,9 @@ pub use agent::{
     render_skill_md, write_mcp_scaffold, write_skill_md, EdgePattern, EdgeSource, GraphSchema,
     McpScaffoldContext, SchemaEdge, SkillRenderContext,
 };
+pub use batch::{
+    apply_memory_batch, validate_memory_batch, MemoryBatchOperation, MemoryBatchResult,
+};
 pub use config::{
     LakehouseCacheConfig, LakehouseConfig, MagGraphConfig, RemoteSource, ResolvedConfig,
     StorageConfig, StorageMode, SyncConfig, SyncRole, METADATA_DIR_NAME,
@@ -33,9 +37,15 @@ pub use lakehouse::{
     ContentCache, ContentResolver, FileResolver, HttpResolver, LakehouseReader, NodeWithContent,
     ResolvedContent, ResolverRegistry, S3StubResolver,
 };
-pub use memory::{new_memory_node, validate_memory_type, MemoryNodeKind, MEMORY_TYPES};
+pub use memory::{
+    new_memory_node, new_memory_node_with_context, validate_memory_type, MemoryContext,
+    MemoryNodeKind, MEMORY_TYPES,
+};
 pub use node::{NewNode, Node, NodeMetadata};
-pub use query::{changed_since, search_index, GraphChange, QueryOptions, SearchResult};
+pub use query::{
+    changed_since, hybrid_search_index, search_index, GraphChange, HybridQueryOptions,
+    HybridSearchResult, HybridWeights, QueryOptions, SearchResult,
+};
 pub use recall::{recall_bundle, RecallBundle};
 pub use security::{assert_path_within_root, validate_http_uri_host, validate_relative_node_path};
 pub use sync::{