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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Metrics and cache behavior tests for coverage.
//!
//! Covers: FrameworkMetricsSnapshot, cache eviction metrics

use chaotic_semantic_memory::prelude::*;

const NS: &str = "_default";

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

    framework
        .inject_concept("metrics-1", HVec10240::random())
        .await
        .unwrap();

    // Multiple probes should generate cache hits
    let query = HVec10240::random();
    framework.probe(query, 5).await.unwrap();
    framework.probe(query, 5).await.unwrap();

    let metrics = framework.metrics_snapshot().await;
    assert!(metrics.cache_hits_total >= 1);
    assert!(metrics.cache_misses_total >= 1);
}

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

    for i in 0..5 {
        framework
            .inject_concept(&format!("metrics-inject-{i}"), HVec10240::random())
            .await
            .unwrap();
    }

    let metrics = framework.metrics_snapshot().await;
    assert_eq!(metrics.concepts_injected_total, 5);
}

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

    framework
        .inject_concept("assoc-metrics-1", HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept("assoc-metrics-2", HVec10240::random())
        .await
        .unwrap();
    framework
        .associate("assoc-metrics-1", "assoc-metrics-2", 0.8)
        .await
        .unwrap();

    let metrics = framework.metrics_snapshot().await;
    assert_eq!(metrics.associations_created_total, 1);
}

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

    framework
        .inject_concept("probe-metrics", HVec10240::random())
        .await
        .unwrap();

    for _ in 0..3 {
        framework.probe(HVec10240::random(), 5).await.unwrap();
    }

    let metrics = framework.metrics_snapshot().await;
    assert_eq!(metrics.probes_total, 3);
}

#[tokio::test]
async fn cache_eviction_on_capacity_exceeded() {
    let framework = ChaoticSemanticFramework::builder()
        .without_persistence()
        .with_concept_cache_size(2) // Small cache to force eviction
        .build()
        .await
        .unwrap();

    framework
        .inject_concept("evict-1", HVec10240::random())
        .await
        .unwrap();

    // Multiple different queries should cause evictions
    let q1 = HVec10240::random();
    let q2 = HVec10240::random();
    let q3 = HVec10240::random();
    framework.probe(q1, 5).await.unwrap();
    framework.probe(q2, 5).await.unwrap();
    framework.probe(q3, 5).await.unwrap(); // Should evict q1

    let metrics = framework.metrics_snapshot().await;
    assert!(metrics.cache_evictions_total >= 1);
}

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

    framework
        .inject_concept("clear-cache", HVec10240::random())
        .await
        .unwrap();

    // Prime the cache
    framework.probe(HVec10240::random(), 5).await.unwrap();

    // Clear cache
    framework.clear_similarity_cache().await;

    // After clear, metrics should reset (or we can probe again)
    framework.probe(HVec10240::random(), 5).await.unwrap();
    let metrics = framework.metrics_snapshot().await;
    assert!(metrics.cache_misses_total >= 1);
}