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

use chaotic_semantic_memory::prelude::*;
use std::sync::Arc;

const NS: &str = "_default";

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

    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();

    let before = framework.probe(vec_a, 3).await.unwrap();
    assert_eq!(before.len(), 3);

    // Inject d → triggers eviction of one concept to stay at limit
    framework
        .inject_concept("d", HVec10240::random())
        .await
        .unwrap();

    let stats = framework.stats().await.unwrap();
    assert_eq!(stats.concept_count, 3);

    // The new concept must exist; one of the originals was evicted
    let after = framework.probe(vec_a, 3).await.unwrap();
    let ids: Vec<&str> = after.iter().map(|(id, _)| id.as_str()).collect();
    assert!(ids.contains(&"d"));
    assert_eq!(after.len(), 3);
}

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

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

    let before = framework.probe(query, 3).await.unwrap();
    assert_eq!(before.len(), 3);

    framework.delete_concept("y").await.unwrap();

    let after = framework.probe(query, 3).await.unwrap();
    let ids: Vec<&str> = after.iter().map(|(id, _)| id.as_str()).collect();
    assert!(!ids.contains(&"y"));
    assert_eq!(after.len(), 2);
}

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

    let mut handles = Vec::new();

    for i in 0..5 {
        let fw = Arc::clone(&framework);
        handles.push(tokio::spawn(async move {
            fw.inject_concept(format!("inject_{i}"), HVec10240::random())
                .await
                .unwrap();
        }));
    }

    for _ in 0..5 {
        let fw = Arc::clone(&framework);
        handles.push(tokio::spawn(async move {
            let _ = fw.probe(HVec10240::random(), 5).await;
        }));
    }

    for handle in handles {
        handle.await.unwrap();
    }

    let stats = framework.stats().await.unwrap();
    assert_eq!(stats.concept_count, 5);
}