api_gemini 0.5.0

Gemini's API for accessing large language models (LLMs).
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

//! Model deployment and hosting capabilities for production environments.
//!
//! This module provides comprehensive deployment management including orchestration,
//! scaling, monitoring, and deployment strategies (blue-green, canary, rolling).

// Module declarations
pub mod strategies;
pub mod auto_scaling;
pub mod health;
pub mod orchestration;

mod private
{
  use serde::{ Deserialize, Serialize };
  use std::time::SystemTime;

  /// State of a model deployment
  #[ derive( Debug, Clone, PartialEq, Eq, Serialize, Deserialize ) ]
  pub enum DeploymentState
  {
    /// Deployment is being created
    Pending,
    /// Deployment is actively serving traffic
    Active,
    /// Deployment is being updated
    Updating,
    /// Deployment is being scaled
    Scaling,
    /// Deployment is being rolled back
    RollingBack,
    /// Deployment has failed
    Failed,
    /// Deployment has been terminated
    Terminated,
  }

  /// Deployment environment types
  #[ derive( Debug, Clone, PartialEq, Eq, Serialize, Deserialize ) ]
  pub enum DeploymentEnvironment
  {
    /// Development environment
    Development,
    /// Staging environment
    Staging,
    /// Production environment
    Production,
    /// Custom environment
    Custom( String ),
  }

  /// Deployment summary for monitoring and dashboards
  #[ derive( Debug, Clone, Serialize, Deserialize ) ]
  pub struct DeploymentSummary
  {
    /// Deployment identifier
    pub deployment_id : String,
    /// Deployment name
    pub name : String,
    /// Model version
    pub version : String,
    /// Current state
    pub state : DeploymentState,
    /// Environment
    pub environment : DeploymentEnvironment,
    /// Number of instances
    pub instance_count : usize,
    /// CPU utilization percentage
    pub cpu_utilization : f64,
    /// Memory utilization percentage
    pub memory_utilization : f64,
    /// Error rate percentage
    pub error_rate : f64,
    /// Average response time in milliseconds
    pub response_time_ms : f64,
    /// Uptime percentage
    pub uptime_percentage : f64,
    /// Health status
    pub is_healthy : bool,
    /// Creation timestamp
    pub created_at : SystemTime,
    /// Total requests processed
    pub total_requests : u64,
  }

  // Re-exports from submodules
  pub use super::strategies::{ DeploymentStrategy, DeploymentCache };
  pub use super::auto_scaling::{
    ScalingConfig,
    ScalingConfigBuilder,
    ResourceConfig,
    ResourceConfigBuilder,
    IntelligentScaler,
    ScalingDecision,
  };
  pub use super::health::{
    DeploymentHealthCheckConfig,
    DeploymentHealthCheckConfigBuilder,
    MonitoringConfig,
    MonitoringConfigBuilder,
    DeploymentMetrics,
    PerformanceOptimizer,
    OptimizationRecommendation,
    OptimizationCategory,
    OptimizationPriority,
    ImpactEstimate,
    ImplementationEffort,
  };
  pub use super::orchestration::{
    ContainerConfig,
    ContainerConfigBuilder,
    OrchestrationConfig,
    ModelDeployment,
    DeploymentBuilder,
  };
}

::mod_interface::mod_interface!
{
  exposed use private::DeploymentState;
  exposed use private::DeploymentEnvironment;
  exposed use private::DeploymentStrategy;
  exposed use private::ScalingConfig;
  exposed use private::ScalingConfigBuilder;
  exposed use private::ResourceConfig;
  exposed use private::ResourceConfigBuilder;
  exposed use private::DeploymentHealthCheckConfig;
  exposed use private::DeploymentHealthCheckConfigBuilder;
  exposed use private::MonitoringConfig;
  exposed use private::MonitoringConfigBuilder;
  exposed use private::ContainerConfig;
  exposed use private::ContainerConfigBuilder;
  exposed use private::OrchestrationConfig;
  exposed use private::DeploymentMetrics;
  exposed use private::ModelDeployment;
  exposed use private::DeploymentBuilder;
  exposed use private::DeploymentSummary;
  exposed use private::DeploymentCache;
  exposed use private::IntelligentScaler;
  exposed use private::ScalingDecision;
  exposed use private::PerformanceOptimizer;
  exposed use private::OptimizationRecommendation;
  exposed use private::OptimizationCategory;
  exposed use private::OptimizationPriority;
  exposed use private::ImpactEstimate;
  exposed use private::ImplementationEffort;
}