locus-sdk 0.2.2

SDK-first STTP memory primitives and AI provider abstraction
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

use crate::domain::memory::MemorySchemaResult;

pub struct MemorySchemaService;

impl MemorySchemaService {
    pub fn new() -> Self {
        Self
    }

    pub fn execute(&self) -> MemorySchemaResult {
        MemorySchemaResult {
            schema_version: "locus-sdk.memory.v3".to_string(),
            sort_fields: vec![
                "timestamp".to_string(),
                "updated_at".to_string(),
                "psi".to_string(),
                "rho".to_string(),
                "kappa".to_string(),
            ],
            filter_fields: vec![
                "has_embedding".to_string(),
                "embedding_model".to_string(),
                "psi".to_string(),
                "rho".to_string(),
                "kappa".to_string(),
                "text_contains".to_string(),
                "tags_contains".to_string(),
                "has_tag".to_string(),
                "indexed_tags".to_string(),
                "tag_prefix".to_string(),
                "has_semantic_links".to_string(),
                "link_rel".to_string(),
                "link_target".to_string(),
                "links_to_ref".to_string(),
            ],
            group_by_fields: vec![
                "session_id".to_string(),
                "tier".to_string(),
                "embedding_model".to_string(),
                "date_day".to_string(),
                "semantic_tag".to_string(),
            ],
            fallback_policies: vec![
                "never".to_string(),
                "on_empty".to_string(),
                "always".to_string(),
            ],
            strictness_modes: vec![
                "precision".to_string(),
                "balanced".to_string(),
                "recall".to_string(),
            ],
            transform_operations: vec![
                "embed_backfill".to_string(),
                "reindex_embeddings".to_string(),
                "embed_tag_backfill".to_string(),
                "reindex_tag_embeddings".to_string(),
            ],
            evict_operations: vec![
                "delete_nodes".to_string(),
                "purge_session".to_string(),
            ],
        }
    }
}

impl Default for MemorySchemaService {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::MemorySchemaService;

    #[test]
    fn schema_contains_expected_core_fields() {
        let service = MemorySchemaService::new();
        let schema = service.execute();

        assert_eq!(schema.schema_version, "locus-sdk.memory.v3");
        assert!(schema.sort_fields.contains(&"timestamp".to_string()));
        assert!(schema.group_by_fields.contains(&"session_id".to_string()));
        assert!(schema.fallback_policies.contains(&"on_empty".to_string()));
        assert!(schema
            .transform_operations
            .contains(&"embed_backfill".to_string()));
        assert!(schema.filter_fields.contains(&"has_tag".to_string()));
    }

    #[test]
    fn schema_contains_semantic_tag_filters() {
        let service = MemorySchemaService::new();
        let schema = service.execute();

        assert!(schema
            .filter_fields
            .contains(&"tags_contains".to_string()));
        assert!(schema
            .filter_fields
            .contains(&"indexed_tags".to_string()));
        assert!(schema
            .filter_fields
            .contains(&"link_rel".to_string()));
    }
}