chaotic_semantic_memory 0.3.6

AI memory systems with hyperdimensional vectors and chaotic reservoirs
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Cache LRU behavior tests for coverage gap in singularity_cache.rs.
//!
//! Covers: QueryCache::get with LRU update, QueryCache::put with eviction

use chaotic_semantic_memory::prelude::*;

const NS: &str = "_default";

#[tokio::test]
async fn cache_hit_updates_lru_order() {
    let framework = ChaoticSemanticFramework::builder()
        .without_persistence()
        .with_concept_cache_size(4)
        .build()
        .await
        .unwrap();

    // Inject concepts
    let vec_a = HVec10240::random();
    framework.inject_concept("a", vec_a).await.unwrap();
    framework
        .inject_concept("b", HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept("c", HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept("d", HVec10240::random())
        .await
        .unwrap();

    // Query for 'a' multiple times to test cache hit LRU update
    let results1 = framework.probe(vec_a, 2).await.unwrap();
    assert!(results1.iter().any(|(id, _)| id == "a"));

    // Second query should hit cache and update LRU
    let results2 = framework.probe(vec_a, 2).await.unwrap();
    assert!(results2.iter().any(|(id, _)| id == "a"));

    // Inject new concept to trigger potential eviction
    framework
        .inject_concept("e", HVec10240::random())
        .await
        .unwrap();

    // 'a' should still be found due to recent access
    let results3 = framework.probe(vec_a, 5).await.unwrap();
    assert!(results3.iter().any(|(id, _)| id == "a"));
}

#[tokio::test]
async fn cache_capacity_eviction() {
    let framework = ChaoticSemanticFramework::builder()
        .without_persistence()
        .with_concept_cache_size(2) // Very small cache
        .build()
        .await
        .unwrap();

    let vec1 = HVec10240::random();
    framework.inject_concept("c1", vec1).await.unwrap();
    framework
        .inject_concept("c2", HVec10240::random())
        .await
        .unwrap();

    // First query fills cache
    framework.probe(vec1, 1).await.unwrap();

    // Different query evicts old entry
    framework.probe(HVec10240::random(), 1).await.unwrap();

    // Original query causes cache miss
    framework.probe(vec1, 1).await.unwrap();
}

#[tokio::test]
async fn cache_clear_removes_all_entries() {
    let framework = ChaoticSemanticFramework::builder()
        .without_persistence()
        .with_concept_cache_size(16)
        .build()
        .await
        .unwrap();

    let vec1 = HVec10240::random();
    framework.inject_concept("x", vec1).await.unwrap();

    // Query to populate cache
    framework.probe(vec1, 1).await.unwrap();

    // Clear similarity cache (returns (), not Result)
    framework.clear_similarity_cache().await;

    // Next query should be cache miss
    framework.probe(vec1, 1).await.unwrap();
}