Struct EmbeddingsCache 

pub struct EmbeddingsCache {
    pub config: CacheConfig,
}

Redis-backed cache for deterministic content/model embedding lookups.

Fields

config: CacheConfig

Cache configuration.

Implementations

impl EmbeddingsCache

pub fn new(config: CacheConfig) -> Self

Creates a new embeddings cache configuration.

pub fn make_entry_id(&self, content: &str, model_name: &str) -> String

Generates the deterministic cache entry id for a content/model pair.

pub fn make_cache_key(&self, content: &str, model_name: &str) -> String

Generates the full Redis key for a content/model pair.

pub fn get( &self, content: &str, model_name: &str, ) -> Result<Option<EmbeddingCacheEntry>>

Retrieves a cached embedding by content and model name.

pub fn get_by_key(&self, key: &str) -> Result<Option<EmbeddingCacheEntry>>

Retrieves a cached embedding by its Redis key.

pub fn mget<I, S>( &self, contents: I, model_name: &str, ) -> Result<Vec<Option<EmbeddingCacheEntry>>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Retrieves multiple cached embeddings by content and model name.

pub fn mget_by_keys<I, S>( &self, keys: I, ) -> Result<Vec<Option<EmbeddingCacheEntry>>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Retrieves multiple cached embeddings by Redis key.

pub fn set( &self, content: &str, model_name: &str, embedding: &[f32], metadata: Option<Value>, ttl_seconds: Option<u64>, ) -> Result<String>

Stores a cached embedding and returns its Redis key.

pub fn mset( &self, items: &[EmbeddingCacheItem], ttl_seconds: Option<u64>, ) -> Result<Vec<String>>

Stores multiple cached embeddings and returns their Redis keys.

pub fn exists(&self, content: &str, model_name: &str) -> Result<bool>

Checks whether a cached embedding exists for a content/model pair.

pub fn exists_by_key(&self, key: &str) -> Result<bool>

Checks whether a cached embedding exists for a Redis key.

pub fn mexists<I, S>(&self, contents: I, model_name: &str) -> Result<Vec<bool>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Checks whether multiple cached embeddings exist for content/model pairs.

pub fn mexists_by_keys<I, S>(&self, keys: I) -> Result<Vec<bool>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Checks whether multiple cached embeddings exist for Redis keys.

pub fn drop(&self, content: &str, model_name: &str) -> Result<()>

Removes a cached embedding by content and model name.

pub fn drop_by_key(&self, key: &str) -> Result<()>

Removes a cached embedding by Redis key.

pub fn mdrop<I, S>(&self, contents: I, model_name: &str) -> Result<()>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Removes multiple cached embeddings by content and model name.

pub fn mdrop_by_keys<I, S>(&self, keys: I) -> Result<()>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Removes multiple cached embeddings by Redis key.

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

Clears every cache entry under this cache namespace.

pub async fn aget( &self, content: &str, model_name: &str, ) -> Result<Option<EmbeddingCacheEntry>>

Retrieves a cached embedding by content and model name asynchronously.

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

Retrieves a cached embedding by its Redis key asynchronously.

pub async fn amget<I, S>( &self, contents: I, model_name: &str, ) -> Result<Vec<Option<EmbeddingCacheEntry>>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Retrieves multiple cached embeddings by content and model name asynchronously.

pub async fn amget_by_keys<I, S>( &self, keys: I, ) -> Result<Vec<Option<EmbeddingCacheEntry>>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Retrieves multiple cached embeddings by Redis key asynchronously.

pub async fn aset( &self, content: &str, model_name: &str, embedding: &[f32], metadata: Option<Value>, ttl_seconds: Option<u64>, ) -> Result<String>

Stores a cached embedding asynchronously and returns its Redis key.

pub async fn amset( &self, items: &[EmbeddingCacheItem], ttl_seconds: Option<u64>, ) -> Result<Vec<String>>

Stores multiple cached embeddings asynchronously and returns their Redis keys.

pub async fn aexists(&self, content: &str, model_name: &str) -> Result<bool>

Checks whether a cached embedding exists for a content/model pair asynchronously.

pub async fn aexists_by_key(&self, key: &str) -> Result<bool>

Checks whether a cached embedding exists for a Redis key asynchronously.

pub async fn amexists<I, S>( &self, contents: I, model_name: &str, ) -> Result<Vec<bool>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Checks whether multiple cached embeddings exist for content/model pairs asynchronously.

pub async fn amexists_by_keys<I, S>(&self, keys: I) -> Result<Vec<bool>>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Checks whether multiple cached embeddings exist for Redis keys asynchronously.

pub async fn adrop(&self, content: &str, model_name: &str) -> Result<()>

Removes a cached embedding by content and model name asynchronously.

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

Removes a cached embedding by Redis key asynchronously.

pub async fn amdrop<I, S>(&self, contents: I, model_name: &str) -> Result<()>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Removes multiple cached embeddings by content and model name asynchronously.

pub async fn amdrop_by_keys<I, S>(&self, keys: I) -> Result<()>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Removes multiple cached embeddings by Redis key asynchronously.

pub async fn aclear(&self) -> Result<usize>

Clears every cache entry under this cache namespace asynchronously.

Trait Implementations

impl Clone for EmbeddingsCache

fn clone(&self) -> EmbeddingsCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EmbeddingsCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EmbeddingsCache

fn default() -> Self

Returns the “default value” for a type.