1use serde::{Deserialize, Serialize};
4use chrono::{DateTime, Utc};
5use uuid::Uuid;
6use std::collections::HashMap;
7
8#[derive(Debug, Clone, Serialize, Deserialize)]
10pub struct AiModel {
11 pub id: Uuid,
12 pub name: String,
13 pub version: String,
14 pub size_gb: f64,
15 pub model_type: ModelType,
16 pub provider: String,
17 pub description: Option<String>,
18 pub tags: Vec<String>,
19 pub capabilities: Vec<String>,
20 pub requirements: ModelRequirements,
21 pub status: ModelStatus,
22 pub download_url: Option<String>,
23 pub checksum: Option<String>,
24 pub created_at: DateTime<Utc>,
25 pub updated_at: DateTime<Utc>,
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30pub enum ModelType {
31 TextGeneration,
32 ChatCompletion,
33 Embedding,
34 CodeGeneration,
35 ImageGeneration,
36 Multimodal,
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41pub enum ModelStatus {
42 Available, Downloading, Downloaded, Installing, Installed, Running, Stopped, Error, }
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54pub struct ModelRequirements {
55 pub min_ram_gb: f64,
56 pub min_vram_gb: Option<f64>,
57 pub gpu_required: bool,
58 pub cpu_cores: u32,
59 pub disk_space_gb: f64,
60 pub supported_platforms: Vec<String>,
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65pub struct ModelDeployment {
66 pub id: Uuid,
67 pub model_id: Uuid,
68 pub name: String,
69 pub port: u16,
70 pub bind_address: String,
71 pub api_key: String,
72 pub max_concurrent: u32,
73 pub config: DeploymentConfig,
74 pub resource_config: ResourceConfig,
75 pub status: DeploymentStatus,
76 pub pid: Option<u32>,
77 pub started_at: Option<DateTime<Utc>>,
78 pub stopped_at: Option<DateTime<Utc>>,
79 pub created_at: DateTime<Utc>,
80 pub updated_at: DateTime<Utc>,
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
85pub enum DeploymentStatus {
86 Stopped,
87 Starting,
88 Running,
89 Stopping,
90 Error,
91}
92
93#[derive(Debug, Clone, Serialize, Deserialize)]
95pub struct DeploymentConfig {
96 pub auto_start: bool,
97 pub restart_on_failure: bool,
98 pub max_restart_count: u32,
99 pub health_check_interval: u64,
100 pub timeout_seconds: u64,
101 pub log_level: LogLevel,
102 pub custom_args: HashMap<String, String>,
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
107pub struct ResourceConfig {
108 pub context_length: u32,
109 pub temperature: f32,
110 pub top_p: f32,
111 pub top_k: u32,
112 pub max_tokens: u32,
113 pub gpu_layers: Option<u32>,
114 pub threads: Option<u32>,
115 pub batch_size: u32,
116}
117
118#[derive(Debug, Clone, Serialize, Deserialize)]
120pub enum LogLevel {
121 Debug,
122 Info,
123 Warn,
124 Error,
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129pub struct SystemMetrics {
130 pub id: Uuid,
131 pub timestamp: DateTime<Utc>,
132 pub cpu_usage: f64,
133 pub memory_usage: f64,
134 pub memory_total: u64,
135 pub disk_usage: f64,
136 pub disk_total: u64,
137 pub gpu_usage: Option<f64>,
138 pub gpu_memory_usage: Option<f64>,
139 pub network_rx: u64,
140 pub network_tx: u64,
141}
142
143#[derive(Debug, Clone, Serialize, Deserialize)]
145pub struct ModelMetrics {
146 pub id: Uuid,
147 pub deployment_id: Uuid,
148 pub timestamp: DateTime<Utc>,
149 pub request_count: u64,
150 pub error_count: u64,
151 pub average_response_time: f64,
152 pub tokens_per_second: f64,
153 pub concurrent_requests: u32,
154 pub queue_length: u32,
155 pub memory_usage: f64,
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize)]
160pub struct RequestLog {
161 pub id: Uuid,
162 pub deployment_id: Uuid,
163 pub timestamp: DateTime<Utc>,
164 pub method: String,
165 pub endpoint: String,
166 pub status_code: u16,
167 pub response_time_ms: u64,
168 pub input_tokens: Option<u32>,
169 pub output_tokens: Option<u32>,
170 pub user_id: Option<String>,
171 pub client_ip: String,
172 pub user_agent: Option<String>,
173 pub error_message: Option<String>,
174}
175
176#[derive(Debug, Clone, Serialize, Deserialize)]
178pub struct SystemLog {
179 pub id: Uuid,
180 pub timestamp: DateTime<Utc>,
181 pub level: LogLevel,
182 pub component: String,
183 pub message: String,
184 pub context: HashMap<String, String>,
185 pub deployment_id: Option<Uuid>,
186 pub model_id: Option<Uuid>,
187}
188
189#[derive(Debug, Clone, Serialize, Deserialize)]
191pub struct UserSettings {
192 pub id: Uuid,
193 pub user_id: String,
194 pub theme: Theme,
195 pub language: String,
196 pub font_size: FontSize,
197 pub auto_refresh_interval: u32,
198 pub notifications_enabled: bool,
199 pub notification_types: Vec<NotificationType>,
200 pub created_at: DateTime<Utc>,
201 pub updated_at: DateTime<Utc>,
202}
203
204#[derive(Debug, Clone, Serialize, Deserialize)]
206pub enum Theme {
207 Light,
208 Dark,
209 System,
210}
211
212#[derive(Debug, Clone, Serialize, Deserialize)]
214pub enum FontSize {
215 Small,
216 Medium,
217 Large,
218 ExtraLarge,
219}
220
221#[derive(Debug, Clone, Serialize, Deserialize)]
223pub enum NotificationType {
224 ModelStarted,
225 ModelStopped,
226 ModelError,
227 HighResourceUsage,
228 LowDiskSpace,
229 SecurityAlert,
230}
231
232#[derive(Debug, Clone, Serialize, Deserialize)]
234pub struct SecurityConfig {
235 pub id: Uuid,
236 pub api_keys: Vec<ApiKey>,
237 pub rate_limiting: RateLimitConfig,
238 pub access_control: AccessControlConfig,
239 pub firewall_rules: Vec<FirewallRule>,
240 pub created_at: DateTime<Utc>,
241 pub updated_at: DateTime<Utc>,
242}
243
244#[derive(Debug, Clone, Serialize, Deserialize)]
246pub struct ApiKey {
247 pub id: Uuid,
248 pub name: String,
249 pub key_hash: String,
250 pub permissions: Vec<Permission>,
251 pub rate_limit: Option<u32>,
252 pub expires_at: Option<DateTime<Utc>>,
253 pub last_used_at: Option<DateTime<Utc>>,
254 pub created_at: DateTime<Utc>,
255 pub is_active: bool,
256}
257
258#[derive(Debug, Clone, Serialize, Deserialize)]
260pub enum Permission {
261 ModelRead,
262 ModelWrite,
263 ModelDeploy,
264 SystemMonitor,
265 LogsRead,
266 SettingsRead,
267 SettingsWrite,
268 AdminAll,
269}
270
271#[derive(Debug, Clone, Serialize, Deserialize)]
273pub struct AccessControlConfig {
274 pub allow_localhost_only: bool,
275 pub allowed_ips: Vec<String>,
276 pub blocked_ips: Vec<String>,
277 pub require_api_key: bool,
278 pub session_timeout: u32,
279}
280
281#[derive(Debug, Clone, Serialize, Deserialize)]
283pub struct RateLimitConfig {
284 pub enabled: bool,
285 pub requests_per_minute: u32,
286 pub requests_per_hour: u32,
287 pub burst_limit: u32,
288 pub whitelist_ips: Vec<String>,
289}
290
291#[derive(Debug, Clone, Serialize, Deserialize)]
293pub struct FirewallRule {
294 pub id: Uuid,
295 pub name: String,
296 pub rule_type: FirewallRuleType,
297 pub source_ip: Option<String>,
298 pub destination_port: Option<u16>,
299 pub protocol: Protocol,
300 pub action: FirewallAction,
301 pub is_enabled: bool,
302 pub created_at: DateTime<Utc>,
303}
304
305#[derive(Debug, Clone, Serialize, Deserialize)]
307pub enum FirewallRuleType {
308 Allow,
309 Deny,
310 Log,
311}
312
313#[derive(Debug, Clone, Serialize, Deserialize)]
315pub enum Protocol {
316 Tcp,
317 Udp,
318 Http,
319 Https,
320}
321
322#[derive(Debug, Clone, Serialize, Deserialize)]
324pub enum FirewallAction {
325 Accept,
326 Drop,
327 Reject,
328 Log,
329}