AsyncStorageBackend

llm_memory_graph::storage

Trait AsyncStorageBackend 

Source 
pub trait AsyncStorageBackend: Send + Sync {

Show 15 methods    // Required methods
    fn store_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        node: &'life1 Node,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NodeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Node>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 NodeId,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn store_edge<'life0, 'life1, 'async_trait>(
        &'life0 self,
        edge: &'life1 Edge,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_edge<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 EdgeId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Edge>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_edge<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 EdgeId,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_session_nodes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        session_id: &'life1 SessionId,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_outgoing_edges<'life0, 'life1, 'async_trait>(
        &'life0 self,
        node_id: &'life1 NodeId,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_incoming_edges<'life0, 'life1, 'async_trait>(
        &'life0 self,
        node_id: &'life1 NodeId,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn flush<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn stats<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<StorageStats>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided methods
    fn store_nodes_batch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        nodes: &'life1 [Node],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<NodeId>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn store_edges_batch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        edges: &'life1 [Edge],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<EdgeId>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_session_nodes_stream(
        &self,
        session_id: &SessionId,
    ) -> Pin<Box<dyn Stream<Item = Result<Node>> + Send + '_>> { ... }
    fn count_session_nodes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        session_id: &'life1 SessionId,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }

}
Expand description

Async trait defining storage backend operations

This trait provides async versions of all storage operations for use with Tokio runtime. It enables high-performance concurrent operations and non-blocking I/O.

Required Methods§

Source

fn store_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 Node, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a node in the backend asynchronously

Source

fn get_node<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Node>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a node by ID asynchronously

Source

fn delete_node<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a node asynchronously

Source

fn store_edge<'life0, 'life1, 'async_trait>( &'life0 self, edge: &'life1 Edge, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store an edge asynchronously

Source

fn get_edge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 EdgeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Edge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve an edge by ID asynchronously

Source

fn delete_edge<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 EdgeId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an edge asynchronously

Source

fn get_session_nodes<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Node>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all nodes in a session asynchronously

Source

fn get_outgoing_edges<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all edges from a node asynchronously

Source

fn get_incoming_edges<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 NodeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Edge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all edges to a node asynchronously

Source

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Flush any pending writes asynchronously

Source

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StorageStats>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get storage statistics asynchronously

Provided Methods§

Source

fn store_nodes_batch<'life0, 'life1, 'async_trait>( &'life0 self, nodes: &'life1 [Node], ) -> Pin<Box<dyn Future<Output = Result<Vec<NodeId>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Batch store multiple nodes asynchronously for improved performance

Source

fn store_edges_batch<'life0, 'life1, 'async_trait>( &'life0 self, edges: &'life1 [Edge], ) -> Pin<Box<dyn Future<Output = Result<Vec<EdgeId>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Batch store multiple edges asynchronously for improved performance

Source

fn get_session_nodes_stream( &self, session_id: &SessionId, ) -> Pin<Box<dyn Stream<Item = Result<Node>> + Send + '_>>

Stream nodes from a session for memory-efficient iteration over large result sets

This method returns a stream that yields nodes one at a time, avoiding the need to load all nodes into memory at once. This is particularly useful for sessions with thousands of nodes.

§Examples
use llm_memory_graph::storage::AsyncSledBackend;
use llm_memory_graph::storage::AsyncStorageBackend;
use llm_memory_graph::types::SessionId;
use futures::stream::StreamExt;

let backend = AsyncSledBackend::open("./data/graph.db").await?;
let session_id = SessionId::new();

let mut stream = backend.get_session_nodes_stream(&session_id);
let mut count = 0;
while let Some(node) = stream.next().await {
    let node = node?;
    // Process node without loading all into memory
    count += 1;
}
println!("Processed {} nodes", count);
Source

fn count_session_nodes<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 SessionId, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Count nodes in a session without loading them into memory

This is more efficient than get_session_nodes().await?.len() for large sessions as it only counts without deserializing node data.

§Examples
use llm_memory_graph::storage::AsyncSledBackend;
use llm_memory_graph::storage::AsyncStorageBackend;
use llm_memory_graph::types::SessionId;

let backend = AsyncSledBackend::open("./data/graph.db").await?;
let session_id = SessionId::new();

let count = backend.count_session_nodes(&session_id).await?;
println!("Session has {} nodes", count);

Implementors§