cortex-mem-service 1.0.0

HTTP API service for Rust agent memory system
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

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Request to create a new memory
#[derive(Debug, Deserialize)]
pub struct CreateMemoryRequest {
    pub content: String,
    pub user_id: Option<String>,
    pub agent_id: Option<String>,
    pub run_id: Option<String>,
    pub actor_id: Option<String>,
    pub role: Option<String>,
    pub memory_type: Option<String>,
    pub custom: Option<HashMap<String, serde_json::Value>>,
}

/// Request to update an existing memory
#[derive(Debug, Deserialize)]
pub struct UpdateMemoryRequest {
    pub content: String,
}

/// Request to batch delete memories
#[derive(Debug, Deserialize)]
pub struct BatchDeleteRequest {
    pub ids: Vec<String>,
}

/// Request to batch update memories
#[derive(Debug, Deserialize)]
pub struct BatchUpdateRequest {
    pub updates: Vec<MemoryUpdate>,
}

/// Single memory update for batch operation
#[derive(Debug, Deserialize)]
pub struct MemoryUpdate {
    pub id: String,
    pub content: String,
}

/// Response for batch operations
#[derive(Debug, Serialize)]
pub struct BatchOperationResponse {
    pub success_count: usize,
    pub failure_count: usize,
    pub errors: Vec<String>,
    pub message: String,
}

/// Request to search memories
#[derive(Debug, Deserialize)]
pub struct SearchMemoryRequest {
    pub query: String,
    pub user_id: Option<String>,
    pub agent_id: Option<String>,
    pub run_id: Option<String>,
    pub actor_id: Option<String>,
    pub memory_type: Option<String>,
    pub limit: Option<usize>,
    pub similarity_threshold: Option<f32>,
}

/// Query parameters for listing memories
#[derive(Debug, Deserialize)]
pub struct ListMemoryQuery {
    pub user_id: Option<String>,
    pub agent_id: Option<String>,
    pub run_id: Option<String>,
    pub actor_id: Option<String>,
    pub memory_type: Option<String>,
    pub limit: Option<usize>,
}

/// Response for memory operations
#[derive(Debug, Serialize)]
pub struct MemoryResponse {
    pub id: String,
    pub content: String,
    pub metadata: MemoryMetadataResponse,
    pub created_at: String,
    pub updated_at: String,
}

/// Response for memory metadata
#[derive(Debug, Serialize)]
pub struct MemoryMetadataResponse {
    pub user_id: Option<String>,
    pub agent_id: Option<String>,
    pub run_id: Option<String>,
    pub actor_id: Option<String>,
    pub role: Option<String>,
    pub memory_type: String,
    pub hash: String,
    pub importance_score: Option<f32>,
    pub custom: HashMap<String, serde_json::Value>,
}

/// Response for search results
#[derive(Debug, Serialize)]
pub struct SearchResponse {
    pub results: Vec<ScoredMemoryResponse>,
    pub total: usize,
}

/// Response for scored memory
#[derive(Debug, Serialize)]
pub struct ScoredMemoryResponse {
    pub memory: MemoryResponse,
    pub score: f32,
}

/// Response for list results
#[derive(Debug, Serialize)]
pub struct ListResponse {
    pub memories: Vec<MemoryResponse>,
    pub total: usize,
}

/// Response for successful operations
#[derive(Debug, Serialize)]
pub struct SuccessResponse {
    pub message: String,
    pub id: Option<String>,
}

/// Error response
#[derive(Debug, Serialize)]
pub struct ErrorResponse {
    pub error: String,
    pub code: String,
}

/// Health check response
#[derive(Debug, Serialize)]
pub struct HealthResponse {
    pub status: String,
    pub vector_store: bool,
    pub llm_service: bool,
    pub timestamp: String,
}

/// LLM service status response
#[derive(Debug, Serialize)]
pub struct LLMStatusResponse {
    pub overall_status: String,
    pub completion_model: ModelStatus,
    pub embedding_model: ModelStatus,
    pub timestamp: String,
}

/// Individual model status
#[derive(Debug, Serialize)]
pub struct ModelStatus {
    pub available: bool,
    pub provider: String,
    pub model_name: String,
    pub latency_ms: Option<u64>,
    pub error_message: Option<String>,
    pub last_check: String,
}

/// Simple health check response for LLM services
#[derive(Debug, Serialize)]
pub struct LLMHealthResponse {
    pub completion_model_available: bool,
    pub embedding_model_available: bool,
    pub timestamp: String,
}