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

//! Framework builder configuration coverage tests.
//!
//! Covers: with_max_sequence_length, with_max_metadata_bytes, with_version_retention

use chaotic_semantic_memory::prelude::*;
use tempfile::NamedTempFile;

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

    // Verify framework was created with custom config
    let stats = framework.stats().await.unwrap();
    assert_eq!(stats.concept_count, 0);
}

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

    // Small metadata should work
    let small_meta =
        std::collections::HashMap::from([("key".to_string(), serde_json::json!("value"))]);
    framework
        .inject_concept_with_metadata("meta-small", HVec10240::random(), small_meta)
        .await
        .unwrap();
}

#[tokio::test]
async fn builder_with_version_retention_configured() {
    let temp = NamedTempFile::new().unwrap();
    let db_path = temp.path().to_str().unwrap().to_string();

    let framework = ChaoticSemanticFramework::builder()
        .with_local_db(db_path)
        .with_version_retention(3)
        .build()
        .await
        .unwrap();

    framework
        .inject_concept("version-retention", HVec10240::random())
        .await
        .unwrap();

    // Multiple updates to create versions
    for _ in 0..5 {
        framework
            .update_concept_vector("version-retention", HVec10240::random())
            .await
            .unwrap();
    }

    // History should be limited by retention
    let history = framework
        .concept_history("version-retention", 10)
        .await
        .unwrap();
    assert!(history.len() <= 3);
}

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

    // Small batch should work
    let concepts: Vec<(String, HVec10240)> = (0..3)
        .map(|i| (format!("batch-{i}"), HVec10240::random()))
        .collect();
    framework.inject_concepts(&concepts).await.unwrap();

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

#[tokio::test]
async fn builder_with_connection_pool_size_configured() {
    let temp = NamedTempFile::new().unwrap();
    let db_path = temp.path().to_str().unwrap().to_string();

    let framework = ChaoticSemanticFramework::builder()
        .with_local_db(db_path)
        .with_connection_pool_size(5)
        .build()
        .await
        .unwrap();

    framework
        .inject_concept("pool-test", HVec10240::random())
        .await
        .unwrap();

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

#[tokio::test]
async fn builder_with_chaos_strength_configured() {
    let framework = ChaoticSemanticFramework::builder()
        .without_persistence()
        .with_chaos_strength(0.5)
        .with_reservoir_size(1000)
        .build()
        .await
        .unwrap();

    // Framework should be created with custom reservoir config
    framework
        .inject_concept("chaos-test", HVec10240::random())
        .await
        .unwrap();

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