mem0-rust 0.2.0

Rust implementation of mem0 - Universal memory layer for AI Agents
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

//! Metadata filter utilities.

use crate::models::{FilterCondition, FilterLogic, FilterOperator, Filters};

/// Builder for creating filters
pub struct FilterBuilder {
    conditions: Vec<FilterCondition>,
    logic: FilterLogic,
}

impl FilterBuilder {
    /// Create a new filter builder with AND logic
    pub fn new() -> Self {
        Self {
            conditions: Vec::new(),
            logic: FilterLogic::And,
        }
    }

    /// Create a new filter builder with OR logic
    pub fn new_or() -> Self {
        Self {
            conditions: Vec::new(),
            logic: FilterLogic::Or,
        }
    }

    /// Add an equality condition
    pub fn eq(mut self, field: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Eq,
            value: value.into(),
        });
        self
    }

    /// Add a not-equal condition
    pub fn ne(mut self, field: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Ne,
            value: value.into(),
        });
        self
    }

    /// Add a greater-than condition
    pub fn gt(mut self, field: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Gt,
            value: value.into(),
        });
        self
    }

    /// Add a greater-than-or-equal condition
    pub fn gte(mut self, field: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Gte,
            value: value.into(),
        });
        self
    }

    /// Add a less-than condition
    pub fn lt(mut self, field: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Lt,
            value: value.into(),
        });
        self
    }

    /// Add a less-than-or-equal condition
    pub fn lte(mut self, field: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Lte,
            value: value.into(),
        });
        self
    }

    /// Add an "in list" condition
    pub fn r#in(mut self, field: impl Into<String>, values: Vec<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::In,
            value: serde_json::Value::Array(values),
        });
        self
    }

    /// Add a "not in list" condition
    pub fn nin(mut self, field: impl Into<String>, values: Vec<serde_json::Value>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Nin,
            value: serde_json::Value::Array(values),
        });
        self
    }

    /// Add a contains condition (case-sensitive)
    pub fn contains(mut self, field: impl Into<String>, value: impl Into<String>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::Contains,
            value: serde_json::Value::String(value.into()),
        });
        self
    }

    /// Add a contains condition (case-insensitive)
    pub fn icontains(mut self, field: impl Into<String>, value: impl Into<String>) -> Self {
        self.conditions.push(FilterCondition {
            field: field.into(),
            operator: FilterOperator::IContains,
            value: serde_json::Value::String(value.into()),
        });
        self
    }

    /// Build the filters
    pub fn build(self) -> Filters {
        Filters {
            conditions: self.conditions,
            logic: self.logic,
        }
    }
}

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

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

    #[test]
    fn test_filter_builder() {
        let filters = FilterBuilder::new()
            .eq("category", serde_json::json!("work"))
            .gt("priority", serde_json::json!(5))
            .build();

        assert_eq!(filters.conditions.len(), 2);
        assert_eq!(filters.logic, FilterLogic::And);
    }

    #[test]
    fn test_filter_builder_or() {
        let filters = FilterBuilder::new_or()
            .eq("status", serde_json::json!("active"))
            .eq("status", serde_json::json!("pending"))
            .build();

        assert_eq!(filters.logic, FilterLogic::Or);
    }
}