oxirs-chat 0.2.4

RAG chat API with LLM integration and natural language to SPARQL translation
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

//! Configuration types for the revolutionary chat optimization framework
//!
//! This module defines configuration structures for unified optimization,
//! advanced statistics, AI-powered conversation analysis, and real-time
//! performance enhancement.

use serde::{Deserialize, Serialize};

/// Revolutionary chat optimization configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RevolutionaryChatConfig {
    /// Enable unified optimization coordination
    pub enable_unified_optimization: bool,
    /// Enable advanced conversation statistics
    pub enable_advanced_statistics: bool,
    /// Enable AI-powered conversation analysis
    pub enable_ai_conversation_analysis: bool,
    /// Enable quantum-enhanced context processing
    pub enable_quantum_context_processing: bool,
    /// Enable real-time streaming optimization
    pub enable_streaming_optimization: bool,
    /// Enable professional memory management
    pub enable_advanced_memory_management: bool,
    /// Unified optimization configuration
    pub unified_config: UnifiedOptimizationConfig,
    /// Statistics collection configuration
    pub statistics_config: AdvancedStatisticsConfig,
    /// Conversation analysis configuration
    pub conversation_analysis_config: ConversationAnalysisConfig,
    /// Performance targets
    pub performance_targets: ChatPerformanceTargets,
}

impl Default for RevolutionaryChatConfig {
    fn default() -> Self {
        Self {
            enable_unified_optimization: true,
            enable_advanced_statistics: true,
            enable_ai_conversation_analysis: true,
            enable_quantum_context_processing: true,
            enable_streaming_optimization: true,
            enable_advanced_memory_management: true,
            unified_config: UnifiedOptimizationConfig::default(),
            statistics_config: AdvancedStatisticsConfig::default(),
            conversation_analysis_config: ConversationAnalysisConfig::default(),
            performance_targets: ChatPerformanceTargets::default(),
        }
    }
}

/// Unified optimization configuration for chat
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnifiedOptimizationConfig {
    /// Enable cross-component coordination
    pub enable_cross_component_coordination: bool,
    /// Enable adaptive optimization strategies
    pub enable_adaptive_strategies: bool,
    /// Enable AI-driven optimization decisions
    pub enable_ai_driven_optimization: bool,
    /// Optimization update frequency in milliseconds
    pub optimization_frequency_ms: u64,
    /// Performance monitoring window size
    pub monitoring_window_size: usize,
    /// Coordination strategy
    pub coordination_strategy: CoordinationStrategy,
}

impl Default for UnifiedOptimizationConfig {
    fn default() -> Self {
        Self {
            enable_cross_component_coordination: true,
            enable_adaptive_strategies: true,
            enable_ai_driven_optimization: true,
            optimization_frequency_ms: 100,
            monitoring_window_size: 1000,
            coordination_strategy: CoordinationStrategy::AIControlled,
        }
    }
}

/// Coordination strategy for unified optimization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CoordinationStrategy {
    Independent,
    Sequential,
    Parallel,
    Adaptive,
    AIControlled,
}

/// Advanced statistics configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdvancedStatisticsConfig {
    /// Enable conversation quality metrics
    pub enable_conversation_quality_metrics: bool,
    /// Enable ML-powered conversation prediction
    pub enable_conversation_prediction: bool,
    /// Enable user behavior analysis
    pub enable_user_behavior_analysis: bool,
    /// Enable performance correlation analysis
    pub enable_performance_correlation: bool,
    /// Statistics collection window in minutes
    pub collection_window_minutes: u64,
    /// Historical data retention days
    pub historical_retention_days: u64,
    /// Statistical significance threshold
    pub significance_threshold: f64,
}

impl Default for AdvancedStatisticsConfig {
    fn default() -> Self {
        Self {
            enable_conversation_quality_metrics: true,
            enable_conversation_prediction: true,
            enable_user_behavior_analysis: true,
            enable_performance_correlation: true,
            collection_window_minutes: 60,
            historical_retention_days: 30,
            significance_threshold: 0.95,
        }
    }
}

/// Conversation analysis configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConversationAnalysisConfig {
    /// Enable semantic conversation flow analysis
    pub enable_semantic_flow_analysis: bool,
    /// Enable emotional state tracking
    pub enable_emotional_state_tracking: bool,
    /// Enable conversation pattern recognition
    pub enable_pattern_recognition: bool,
    /// Enable intent prediction
    pub enable_intent_prediction: bool,
    /// Analysis depth level (1-5)
    pub analysis_depth: u8,
    /// Pattern recognition window size
    pub pattern_window_size: usize,
    /// Confidence threshold for predictions
    pub prediction_confidence_threshold: f64,
}

impl Default for ConversationAnalysisConfig {
    fn default() -> Self {
        Self {
            enable_semantic_flow_analysis: true,
            enable_emotional_state_tracking: true,
            enable_pattern_recognition: true,
            enable_intent_prediction: true,
            analysis_depth: 3,
            pattern_window_size: 20,
            prediction_confidence_threshold: 0.75,
        }
    }
}

/// Chat performance targets
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatPerformanceTargets {
    /// Target response time in milliseconds
    pub target_response_time_ms: u64,
    /// Target conversation quality score (0.0-1.0)
    pub target_conversation_quality: f64,
    /// Target user satisfaction score (0.0-1.0)
    pub target_user_satisfaction: f64,
    /// Target memory efficiency (MB per conversation)
    pub target_memory_efficiency_mb: f64,
    /// Target throughput (messages per second)
    pub target_throughput_mps: f64,
}

impl Default for ChatPerformanceTargets {
    fn default() -> Self {
        Self {
            target_response_time_ms: 2000,
            target_conversation_quality: 0.85,
            target_user_satisfaction: 0.9,
            target_memory_efficiency_mb: 50.0,
            target_throughput_mps: 100.0,
        }
    }
}