Struct RedbStorage 

pub struct RedbStorage { /* private fields */ }

redb storage backend for fast caching

Implementations

impl RedbStorage

pub async fn store_embedding_raw( &self, id: &str, embedding: &[f32], ) -> Result<()>

Store an embedding vector (internal method)

pub async fn get_embedding_raw(&self, id: &str) -> Result<Option<Vec<f32>>>

Retrieve an embedding vector (internal method)

impl RedbStorage

pub async fn store_embedding_impl( &self, id: &str, embedding: Vec<f32>, ) -> Result<()>

Store embedding implementation

pub async fn get_embedding_impl(&self, id: &str) -> Result<Option<Vec<f32>>>

Retrieve embedding implementation

pub async fn delete_embedding_impl(&self, id: &str) -> Result<bool>

Delete embedding implementation

pub async fn store_embeddings_batch_impl( &self, embeddings: Vec<(String, Vec<f32>)>, ) -> Result<()>

Store multiple embeddings in batch implementation

pub async fn get_embeddings_batch_impl( &self, ids: &[String], ) -> Result<Vec<Option<Vec<f32>>>>

Get multiple embeddings in batch implementation

impl RedbStorage

pub async fn store_episode(&self, episode: &Episode) -> Result<()>

Store an episode in cache

pub async fn get_episode(&self, episode_id: Uuid) -> Result<Option<Episode>>

Retrieve an episode from cache

pub async fn get_all_episodes(&self, query: &RedbQuery) -> Result<Vec<Episode>>

Get all episodes from cache (with optional limit)

pub async fn delete_episode(&self, episode_id: Uuid) -> Result<()>

Delete an episode from cache

impl RedbStorage

pub async fn query_episodes_since( &self, since: DateTime<Utc>, limit: Option<usize>, ) -> Result<Vec<Episode>>

Query episodes modified since a given timestamp

Returns all episodes where start_time >= the given timestamp. This is used for incremental synchronization.

Note: This scans all episodes in the cache and filters by timestamp, which may be slow for large datasets. Consider using Turso for efficient timestamp-based queries.

Arguments

• since - Timestamp to query from
• limit - Maximum number of episodes to return (default: 100, max: 1000)

pub async fn query_episodes_by_metadata( &self, key: &str, value: &str, limit: Option<usize>, ) -> Result<Vec<Episode>>

Query episodes by metadata key-value pair

This method searches through all episodes and returns those whose metadata contains the specified key-value pair. This is less efficient than timestamp-based queries but necessary for metadata-based searches.

Arguments

• key - Metadata key to search for
• value - Metadata value to match
• limit - Maximum number of episodes to return (default: 100, max: 1000)

Returns

Vector of episodes matching the metadata criteria

impl RedbStorage

pub async fn store_metadata(&self, key: &str, value: &str) -> Result<()>

Store metadata value

pub async fn get_metadata(&self, key: &str) -> Result<Option<String>>

Retrieve metadata value

pub async fn store_episode_summary( &self, summary: &EpisodeSummary, ) -> Result<()>

Store an episode summary.

Stores a semantic summary of an episode for efficient retrieval. Uses postcard serialization for compact storage.

Arguments

• summary - The episode summary to store

Returns

Ok(()) on success, error otherwise.

Examples

let summary = EpisodeSummary {
    episode_id: Uuid::new_v4(),
    summary_text: "Task completed successfully".to_string(),
    key_concepts: vec!["rust".to_string(), "testing".to_string()],
    key_steps: vec!["Step 1: Initialize".to_string()],
    summary_embedding: None,
    created_at: Utc::now(),
};

storage.store_episode_summary(&summary).await?;

pub async fn get_episode_summary( &self, episode_id: Uuid, ) -> Result<Option<EpisodeSummary>>

Retrieve an episode summary.

Arguments

• episode_id - ID of the episode whose summary to retrieve

Returns

The episode summary if found, None otherwise.

Examples

let episode_id = Uuid::new_v4();
if let Some(summary) = storage.get_episode_summary(episode_id).await? {
    println!("Summary: {}", summary.summary_text);
}

pub async fn store_episode_with_capacity( &self, episode: &Episode, summary: Option<&EpisodeSummary>, capacity_manager: &CapacityManager, ) -> Result<Option<Vec<Uuid>>>

Store an episode with capacity enforcement.

This method enforces capacity limits by evicting low-relevance episodes when storage is full. The eviction and insertion happen atomically in a single write transaction to ensure consistency.

Arguments

• episode - The episode to store
• summary - Optional episode summary to store alongside
• capacity_manager - Manager that determines eviction policy

Returns

Ok(Some(evicted_ids)) if episodes were evicted, Ok(None) if no eviction needed.

Examples

let capacity_mgr = CapacityManager::new(100, EvictionPolicy::RelevanceWeighted);
let episode = Episode::new(
    "Test task".to_string(),
    TaskContext::default(),
    TaskType::Testing,
);

let evicted = storage.store_episode_with_capacity(&episode, None, &capacity_mgr).await?;
if let Some(evicted_ids) = evicted {
    println!("Evicted {} episodes", evicted_ids.len());
}

impl RedbStorage

pub async fn store_heuristic(&self, heuristic: &Heuristic) -> Result<()>

Store a heuristic in cache

pub async fn get_heuristic( &self, heuristic_id: Uuid, ) -> Result<Option<Heuristic>>

Retrieve a heuristic from cache

pub async fn get_all_heuristics( &self, query: &RedbQuery, ) -> Result<Vec<Heuristic>>

Get all heuristics from cache (with optional limit)

impl RedbStorage

pub async fn store_pattern(&self, pattern: &Pattern) -> Result<()>

Store a pattern in cache

pub async fn get_pattern( &self, pattern_id: PatternId, ) -> Result<Option<Pattern>>

Retrieve a pattern from cache

pub async fn get_all_patterns(&self, query: &RedbQuery) -> Result<Vec<Pattern>>

Get all patterns from cache (with optional limit)

impl RedbStorage

pub async fn store_recommendation_session( &self, session: &RecommendationSession, ) -> Result<()>

pub async fn get_recommendation_session( &self, session_id: Uuid, ) -> Result<Option<RecommendationSession>>

pub async fn get_recommendation_session_for_episode( &self, episode_id: Uuid, ) -> Result<Option<RecommendationSession>>

pub async fn store_recommendation_feedback( &self, feedback: &RecommendationFeedback, ) -> Result<()>

pub async fn get_recommendation_feedback( &self, session_id: Uuid, ) -> Result<Option<RecommendationFeedback>>

pub async fn get_recommendation_stats(&self) -> Result<RecommendationStats>

impl RedbStorage

pub async fn store_relationship( &self, relationship: &EpisodeRelationship, ) -> Result<()>

Store a relationship (StorageBackend trait)

pub async fn remove_relationship(&self, relationship_id: Uuid) -> Result<()>

Remove a relationship (StorageBackend trait)

pub async fn get_relationships( &self, episode_id: Uuid, direction: Direction, ) -> Result<Vec<EpisodeRelationship>>

Get relationships (StorageBackend trait)

pub async fn relationship_exists( &self, from_episode_id: Uuid, to_episode_id: Uuid, relationship_type: RelationshipType, ) -> Result<bool>

Check if relationship exists (StorageBackend trait)

pub fn cache_relationship( &self, relationship: &EpisodeRelationship, ) -> Result<()>

Cache a relationship

pub fn get_cached_relationship( &self, relationship_id: Uuid, ) -> Result<Option<EpisodeRelationship>>

Get a cached relationship by ID

pub fn remove_cached_relationship(&self, relationship_id: Uuid) -> Result<()>

Remove a relationship from cache

pub fn get_cached_relationships( &self, episode_id: Uuid, direction: Direction, ) -> Result<Vec<EpisodeRelationship>>

Get all cached relationships for an episode

pub fn clear_relationships_cache(&self) -> Result<()>

Clear all cached relationships

pub fn count_cached_relationships(&self) -> Result<usize>

Get count of cached relationships

impl RedbStorage

pub async fn clear_all(&self) -> Result<()>

Clear all cached data (use with caution!)

impl RedbStorage

pub async fn get_statistics(&self) -> Result<StorageStatistics>

Get database statistics

pub async fn health_check(&self) -> Result<bool>

Health check - verify database accessibility

pub async fn get_cache_metrics(&self) -> CacheMetrics

Get cache metrics

Returns current cache performance metrics including hit rate, miss rate, eviction count, and size statistics.

Example

let metrics = storage.get_cache_metrics().await;
println!("Cache hit rate: {:.2}%", metrics.hit_rate * 100.0);
println!("Cache size: {} items, {} bytes", metrics.item_count, metrics.total_size_bytes);

pub async fn cleanup_cache(&self) -> usize

Manually trigger cache cleanup to remove expired entries

Returns the number of expired entries removed.

This is useful for testing or when you want to force cleanup without waiting for the background task.

impl RedbStorage

pub async fn new(path: &Path) -> Result<Self>

Create a new redb storage instance with default adaptive cache

Uses AdaptiveCacheAdapter by default for intelligent TTL adjustment.

Arguments

• path - Path to the redb database file

Example

let storage = RedbStorage::new(Path::new("./memory.redb")).await?;

pub async fn new_with_cache_config( path: &Path, cache_config: CacheConfig, ) -> Result<Self>

Create a new redb storage instance with custom cache configuration

Uses the legacy LRUCache implementation. For adaptive TTL features, use new_with_adaptive_config instead.

Arguments

• path - Path to the redb database file
• cache_config - Cache configuration settings

Example

let config = CacheConfig {
    max_size: 500,
    default_ttl_secs: 1800,
    cleanup_interval_secs: 600,
    enable_background_cleanup: true,
};
let storage = RedbStorage::new_with_cache_config(Path::new("./memory.redb"), config).await?;

pub async fn new_with_adaptive_config( path: &Path, config: AdaptiveCacheConfig, ) -> Result<Self>

Create a new redb storage instance with adaptive cache configuration

Uses AdaptiveCacheAdapter for intelligent TTL adjustment based on access patterns. Frequently accessed items get longer TTL, rarely accessed items get shorter TTL.

Arguments

• path - Path to the redb database file
• config - Adaptive cache configuration settings

Example

let config = AdaptiveCacheConfig {
    max_size: 1000,
    default_ttl: Duration::from_secs(1800),
    min_ttl: Duration::from_secs(300),
    max_ttl: Duration::from_secs(7200),
    ..Default::default()
};
let storage = RedbStorage::new_with_adaptive_config(Path::new("./memory.redb"), config).await?;

Trait Implementations

impl EmbeddingStorageBackend for RedbStorage

fn store_episode_embedding<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Store an episode embedding

fn store_pattern_embedding<'life0, 'async_trait>( &'life0 self, pattern_id: PatternId, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Store a pattern embedding

fn get_episode_embedding<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get an episode embedding

fn get_pattern_embedding<'life0, 'async_trait>( &'life0 self, pattern_id: PatternId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a pattern embedding

fn find_similar_episodes<'life0, 'async_trait>( &'life0 self, query_embedding: Vec<f32>, limit: usize, threshold: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<SimilaritySearchResult<Episode>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Find similar episodes using vector similarity

fn find_similar_patterns<'life0, 'async_trait>( &'life0 self, query_embedding: Vec<f32>, limit: usize, threshold: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<SimilaritySearchResult<Pattern>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Find similar patterns using vector similarity

impl StorageBackend for RedbStorage

fn store_episode<'life0, 'life1, 'async_trait>( &'life0 self, episode: &'life1 Episode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store an episode

fn get_episode<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Episode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve an episode by ID

fn delete_episode<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete an episode by ID

fn store_pattern<'life0, 'life1, 'async_trait>( &'life0 self, pattern: &'life1 Pattern, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a pattern

fn get_pattern<'life0, 'async_trait>( &'life0 self, id: PatternId, ) -> Pin<Box<dyn Future<Output = Result<Option<Pattern>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a pattern by ID

fn store_heuristic<'life0, 'life1, 'async_trait>( &'life0 self, heuristic: &'life1 Heuristic, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a heuristic

fn get_heuristic<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Heuristic>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a heuristic by ID

fn query_episodes_since<'life0, 'async_trait>( &'life0 self, since: DateTime<Utc>, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Episode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Query episodes modified since a given timestamp

fn query_episodes_by_metadata<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, value: &'life2 str, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Episode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Query episodes by metadata key-value pair

fn store_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store embedding for an episode or pattern

fn get_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve embedding by ID

fn delete_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete embedding by ID

fn store_embeddings_batch<'life0, 'async_trait>( &'life0 self, embeddings: Vec<(String, Vec<f32>)>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Store multiple embeddings in batch

fn get_embeddings_batch<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Vec<f32>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get embeddings for multiple IDs

fn store_relationship<'life0, 'life1, 'async_trait>( &'life0 self, relationship: &'life1 EpisodeRelationship, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a relationship between two episodes

fn remove_relationship<'life0, 'async_trait>( &'life0 self, relationship_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Remove a relationship by ID

fn get_relationships<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, direction: Direction, ) -> Pin<Box<dyn Future<Output = Result<Vec<EpisodeRelationship>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get relationships for an episode

fn relationship_exists<'life0, 'async_trait>( &'life0 self, from_episode_id: Uuid, to_episode_id: Uuid, relationship_type: RelationshipType, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Check if a relationship exists

fn store_recommendation_session<'life0, 'life1, 'async_trait>( &'life0 self, session: &'life1 RecommendationSession, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist a recommendation session for durability and analytics.

fn get_recommendation_session<'life0, 'async_trait>( &'life0 self, session_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationSession>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve a recommendation session by ID.

fn get_recommendation_session_for_episode<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationSession>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve the most recent recommendation session for an episode.

fn store_recommendation_feedback<'life0, 'life1, 'async_trait>( &'life0 self, feedback: &'life1 RecommendationFeedback, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist feedback associated with a recommendation session.

fn get_recommendation_feedback<'life0, 'async_trait>( &'life0 self, session_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationFeedback>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieve feedback for a recommendation session.

fn get_recommendation_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<RecommendationStats>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Compute global recommendation statistics.

fn cleanup_episodes<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 EpisodeRetentionPolicy, ) -> Pin<Box<dyn Future<Output = Result<CleanupResult, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Clean up expired episodes based on retention policy

fn count_cleanup_candidates<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 EpisodeRetentionPolicy, ) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Get count of episodes that would be cleaned up (dry run)