chaotic_semantic_memory 0.3.8

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

#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use chaotic_semantic_memory::prelude::*;
use rand::RngExt;
use std::sync::Arc;
use tokio::task::JoinHandle;

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

    let num_tasks = 100;
    let ops_per_task = 50;
    let mut handles: Vec<JoinHandle<()>> = Vec::with_capacity(num_tasks);

    for t in 0..num_tasks {
        let fw = Arc::clone(&framework);
        handles.push(tokio::spawn(async move {
            for i in 0..ops_per_task {
                let op = {
                    let mut rng = rand::rng();
                    rng.random_range(0..5)
                };
                let id = format!("task-{t}-op-{i}");

                match op {
                    0 => {
                        // Inject
                        fw.inject_concept(&id, HVec10240::random()).await.unwrap();
                    }
                    1 => {
                        // Probe
                        let _ = fw.probe(HVec10240::random(), 5).await.unwrap();
                    }
                    2 => {
                        // Associate
                        let to_id = {
                            let mut rng = rand::rng();
                            format!("task-{t}-op-{}", rng.random_range(0..ops_per_task))
                        };
                        let _ = fw.associate(&id, &to_id, 0.5).await;
                    }
                    3 => {
                        // Delete
                        let _ = fw.delete_concept(&id).await;
                    }
                    _ => {
                        // Stats
                        let _ = fw.stats().await.unwrap();
                    }
                }
            }
        }));
    }

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

    let stats = framework.stats().await.unwrap();
    println!(
        "In-memory stress test complete. Final concept count: {}",
        stats.concept_count
    );
}

#[cfg(feature = "persistence")]
#[tokio::test]
async fn stress_test_high_concurrency_with_persistence() {
    let temp_dir = tempfile::tempdir().unwrap();
    let db_path = temp_dir
        .path()
        .join("stress.db")
        .to_str()
        .unwrap()
        .to_string();

    let framework = Arc::new(
        ChaoticSemanticFramework::builder()
            .with_local_db(&db_path)
            .build()
            .await
            .unwrap(),
    );

    let num_tasks = 100;
    let ops_per_task = 20; // Fewer ops because persistence is slower
    let mut handles: Vec<JoinHandle<()>> = Vec::with_capacity(num_tasks);

    for t in 0..num_tasks {
        let fw = Arc::clone(&framework);
        handles.push(tokio::spawn(async move {
            for i in 0..ops_per_task {
                let op = {
                    let mut rng = rand::rng();
                    rng.random_range(0..5)
                };
                let id = format!("persist-task-{t}-op-{i}");

                match op {
                    0 => {
                        fw.inject_concept(&id, HVec10240::random()).await.unwrap();
                    }
                    1 => {
                        let _ = fw.probe(HVec10240::random(), 5).await.unwrap();
                    }
                    2 => {
                        let to_id = {
                            let mut rng = rand::rng();
                            format!("persist-task-{t}-op-{}", rng.random_range(0..ops_per_task))
                        };
                        let _ = fw.associate(&id, &to_id, 0.5).await;
                    }
                    3 => {
                        let _ = fw.delete_concept(&id).await;
                    }
                    _ => {
                        let _ = fw.stats().await.unwrap();
                    }
                }
            }
        }));
    }

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

    let stats = framework.stats().await.unwrap();
    println!(
        "Persistence stress test complete. Final concept count: {}, DB size: {:?}",
        stats.concept_count, stats.db_size_bytes
    );
}