reflex-cache 0.2.2

Episodic memory and high-speed semantic cache for LLM responses
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use crate::cache::BqSearchBackend;
use crate::vectordb::{SearchResult, VectorDbError, VectorPoint, WriteConsistency};

use super::client::BqClient;
use super::config::BqConfig;

#[cfg(any(test, feature = "mock"))]
use super::mock::MockBqClient;

#[derive(Clone)]
/// Binary-quantized backend wrapper (real or mock).
pub enum BqBackend {
    /// Real Qdrant-backed client.
    Real(BqClient),
    #[cfg(any(test, feature = "mock"))]
    /// In-memory mock backend.
    Mock(MockBqClient),
}

impl BqBackend {
    /// Builds a backend from a URL and config (`mock:` URLs require `mock` feature).
    pub async fn from_config(url: &str, config: BqConfig) -> Result<Self, VectorDbError> {
        if url.starts_with("mock:") {
            #[cfg(any(test, feature = "mock"))]
            {
                Ok(Self::Mock(MockBqClient::with_config(config)))
            }
            #[cfg(not(any(test, feature = "mock")))]
            {
                Err(VectorDbError::ConnectionFailed {
                    url: url.to_string(),
                    message: "Mock backend not enabled. Compile with --features mock".to_string(),
                })
            }
        } else {
            let client = BqClient::with_config(url, config).await?;
            Ok(Self::Real(client))
        }
    }
}

impl BqSearchBackend for BqBackend {
    async fn is_ready(&self) -> bool {
        match self {
            BqBackend::Real(c) => c.health_check().await.is_ok(),
            #[cfg(any(test, feature = "mock"))]
            BqBackend::Mock(_) => true,
        }
    }

    async fn ensure_collection(&self, name: &str, vector_size: u64) -> Result<(), VectorDbError> {
        match self {
            BqBackend::Real(c) => c.ensure_bq_collection(name, vector_size).await,
            #[cfg(any(test, feature = "mock"))]
            BqBackend::Mock(c) => c.ensure_bq_collection(name, vector_size).await,
        }
    }

    async fn search_bq(
        &self,
        collection: &str,
        query: Vec<f32>,
        limit: u64,
        tenant_filter: Option<u64>,
    ) -> Result<Vec<SearchResult>, VectorDbError> {
        match self {
            BqBackend::Real(c) => c.search_bq(collection, query, limit, tenant_filter).await,
            #[cfg(any(test, feature = "mock"))]
            BqBackend::Mock(c) => c.search_bq(collection, query, limit, tenant_filter).await,
        }
    }

    async fn upsert_points(
        &self,
        collection: &str,
        points: Vec<VectorPoint>,
        consistency: WriteConsistency,
    ) -> Result<(), VectorDbError> {
        match self {
            BqBackend::Real(c) => c.upsert_points(collection, points, consistency).await,
            #[cfg(any(test, feature = "mock"))]
            BqBackend::Mock(c) => c.upsert_points(collection, points, consistency).await,
        }
    }
}