tektra 0.2.0

A voice-interactive AI assistant with multimodal capabilities
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

use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use anyhow::Result;
use crate::ai::BackendType;

/// Application configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppConfig {
    /// AI inference backend configuration
    pub inference: InferenceConfig,
    
    /// Model settings
    pub model: ModelConfig,
    
    /// Performance settings
    pub performance: PerformanceConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InferenceConfig {
    /// Backend type to use (Auto, MLX, GGUF)
    pub backend: BackendType,
    
    /// Enable backend benchmarking on startup
    pub benchmark_on_startup: bool,
    
    /// Maximum tokens for generation
    pub max_tokens: usize,
    
    /// Temperature for sampling
    pub temperature: f32,
    
    /// Top-p for nucleus sampling
    pub top_p: f32,
    
    /// Repetition penalty
    pub repeat_penalty: f32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelConfig {
    /// Which Gemma model to use (E2B or E4B)
    pub gemma_variant: String,
    
    /// Use 8-bit quantization instead of 4-bit
    pub use_8bit: bool,
    
    /// Custom model path (if not using HuggingFace)
    pub custom_model_path: Option<PathBuf>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceConfig {
    /// Number of threads to use (None = auto)
    pub n_threads: Option<usize>,
    
    /// Enable memory profiling
    pub profile_memory: bool,
    
    /// Log inference metrics
    pub log_metrics: bool,
}

impl Default for AppConfig {
    fn default() -> Self {
        Self {
            inference: InferenceConfig {
                backend: BackendType::Auto,  // Auto will use MLX on Apple Silicon, GGUF elsewhere
                benchmark_on_startup: false,
                max_tokens: 512,
                temperature: 0.7,
                top_p: 0.9,
                repeat_penalty: 1.1,
            },
            model: ModelConfig {
                gemma_variant: "E2B".to_string(),
                use_8bit: false,
                custom_model_path: None,
            },
            performance: PerformanceConfig {
                n_threads: None,
                profile_memory: false,
                log_metrics: true,
            },
        }
    }
}

impl AppConfig {
    /// Load configuration from file
    pub fn load(path: &PathBuf) -> Result<Self> {
        if path.exists() {
            let content = std::fs::read_to_string(path)?;
            let config: AppConfig = serde_json::from_str(&content)?;
            Ok(config)
        } else {
            Ok(Self::default())
        }
    }
    
    /// Save configuration to file
    pub fn save(&self, path: &PathBuf) -> Result<()> {
        let content = serde_json::to_string_pretty(self)?;
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }
        std::fs::write(path, content)?;
        Ok(())
    }
    
    /// Get the configuration file path
    pub fn get_config_path() -> Result<PathBuf> {
        let config_dir = dirs::config_dir()
            .ok_or_else(|| anyhow::anyhow!("Failed to get config directory"))?
            .join("tektra");
        
        Ok(config_dir.join("config.json"))
    }
}

/// Environment variable overrides
impl AppConfig {
    pub fn apply_env_overrides(&mut self) {
        // Backend override
        if let Ok(backend_str) = std::env::var("TEKTRA_BACKEND") {
            match backend_str.to_lowercase().as_str() {
                "mlx" => self.inference.backend = BackendType::MLX,
                "gguf" => self.inference.backend = BackendType::GGUF,
                "auto" => self.inference.backend = BackendType::Auto,
                _ => tracing::warn!("Unknown backend type in TEKTRA_BACKEND: {}", backend_str),
            }
        }
        
        // Benchmark override
        if let Ok(benchmark_str) = std::env::var("TEKTRA_BENCHMARK") {
            self.inference.benchmark_on_startup = benchmark_str == "1" || benchmark_str.to_lowercase() == "true";
        }
        
        // Thread count override
        if let Ok(threads_str) = std::env::var("TEKTRA_THREADS") {
            if let Ok(threads) = threads_str.parse::<usize>() {
                self.performance.n_threads = Some(threads);
            }
        }
    }
}