chaotic_semantic_memory 0.3.4

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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

//! Tests for Phase 33 API completeness features.

use chaotic_semantic_memory::{ChaoticSemanticFramework, HVec10240};
use std::collections::HashMap;

async fn create_test_framework() -> ChaoticSemanticFramework {
    ChaoticSemanticFramework::builder()
        .without_persistence()
        .build()
        .await
        .unwrap()
}

#[tokio::test]
async fn test_update_concept_vector() {
    let framework = create_test_framework().await;
    let id = "test-concept";
    let vector1 = HVec10240::random();
    let vector2 = HVec10240::random();

    // Inject concept
    framework.inject_concept(id, vector1).await.unwrap();
    let sing = framework.singularity();
    let guard = sing.read().await;
    let concept = guard.get(id).unwrap();
    assert_eq!(concept.vector, vector1);
    drop(guard);

    // Update vector
    framework.update_concept_vector(id, vector2).await.unwrap();
    let sing = framework.singularity();
    let guard = sing.read().await;
    let concept = guard.get(id).unwrap();
    assert_eq!(concept.vector, vector2);
}

#[tokio::test]
async fn test_update_concept_vector_not_found() {
    let framework = create_test_framework().await;
    let vector = HVec10240::random();

    let result = framework.update_concept_vector("nonexistent", vector).await;
    assert!(result.is_err());
}

#[tokio::test]
async fn test_update_concept_metadata() {
    let framework = create_test_framework().await;
    let id = "test-concept";
    let vector = HVec10240::random();

    // Inject concept
    framework.inject_concept(id, vector).await.unwrap();

    // Update metadata
    let mut metadata = HashMap::new();
    metadata.insert("key".to_string(), serde_json::json!("value"));
    framework
        .update_concept_metadata(id, metadata.clone())
        .await
        .unwrap();

    let sing = framework.singularity();
    let guard = sing.read().await;
    let concept = guard.get(id).unwrap();
    assert_eq!(
        concept.metadata.get("key").unwrap(),
        &serde_json::json!("value")
    );
}

#[tokio::test]
async fn test_disassociate() {
    let framework = create_test_framework().await;
    let id1 = "concept-1";
    let id2 = "concept-2";

    framework
        .inject_concept(id1, HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept(id2, HVec10240::random())
        .await
        .unwrap();
    framework.associate(id1, id2, 0.8).await.unwrap();

    // Verify association exists
    let sing = framework.singularity();
    let associations = sing.read().await.get_associations(id1);
    assert_eq!(associations.len(), 1);

    // Disassociate
    framework.disassociate(id1, id2).await.unwrap();

    // Verify association removed
    let associations = framework.singularity().read().await.get_associations(id1);
    assert!(associations.is_empty());
}

#[tokio::test]
async fn test_clear_associations() {
    let framework = create_test_framework().await;
    let id1 = "concept-1";
    let id2 = "concept-2";
    let id3 = "concept-3";

    framework
        .inject_concept(id1, HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept(id2, HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept(id3, HVec10240::random())
        .await
        .unwrap();
    framework.associate(id1, id2, 0.8).await.unwrap();
    framework.associate(id1, id3, 0.6).await.unwrap();

    // Verify associations exist
    let sing = framework.singularity();
    let associations = sing.read().await.get_associations(id1);
    assert_eq!(associations.len(), 2);

    // Clear all associations
    framework.clear_associations(id1).await.unwrap();

    // Verify all associations removed
    let associations = framework.singularity().read().await.get_associations(id1);
    assert!(associations.is_empty());
}

#[tokio::test]
async fn test_bundle_concepts_strict() {
    let framework = create_test_framework().await;
    let id1 = "concept-1";
    let id2 = "concept-2";

    framework
        .inject_concept(id1, HVec10240::random())
        .await
        .unwrap();
    framework
        .inject_concept(id2, HVec10240::random())
        .await
        .unwrap();

    // Bundle existing concepts
    let result = framework
        .bundle_concepts_strict(&[id1.to_string(), id2.to_string()])
        .await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_bundle_concepts_strict_missing() {
    let framework = create_test_framework().await;
    let id1 = "concept-1";

    framework
        .inject_concept(id1, HVec10240::random())
        .await
        .unwrap();

    // Bundle with missing concept
    let result = framework
        .bundle_concepts_strict(&[id1.to_string(), "nonexistent".to_string()])
        .await;
    assert!(result.is_err());
}

#[tokio::test]
async fn test_clear_similarity_cache() {
    let framework = create_test_framework().await;
    let id = "concept-1";
    let vector = HVec10240::random();

    framework.inject_concept(id, vector).await.unwrap();

    // Query to populate cache
    let _ = framework.probe(vector, 10).await.unwrap();

    // Clear cache (should not error)
    framework.clear_similarity_cache().await;
}