tektra 0.2.1

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
147
148
149
150
151

use anyhow::Result;
use std::path::Path;
use std::sync::Arc;
use tokio::sync::Mutex;
use tracing::{info, warn};
use super::inference_backend::{InferenceBackend, InferenceConfig, InferenceMetrics, BackendType};
use super::ollama_inference::OllamaInference;

/// Unified inference manager that can switch between different backends
pub struct InferenceManager {
    backend: Arc<Mutex<Box<dyn InferenceBackend>>>,
    backend_type: BackendType,
}

impl InferenceManager {
    /// Create a new inference manager with the specified backend type
    pub fn new(backend_type: BackendType) -> Result<Self> {
        let backend = Self::create_backend(backend_type)?;
        
        Ok(Self {
            backend: Arc::new(Mutex::new(backend)),
            backend_type,
        })
    }
    
    /// Create the Ollama backend (only option)
    fn create_backend(_backend_type: BackendType) -> Result<Box<dyn InferenceBackend>> {
        info!("Using Ollama backend");
        Ok(Box::new(OllamaInference::new()))
    }
    
    /// Load a model file
    pub async fn load_model(&self, model_path: &Path) -> Result<()> {
        let mut backend = self.backend.lock().await;
        backend.load_model(model_path).await
    }
    
    /// Check if a model is loaded
    pub async fn is_loaded(&self) -> bool {
        let backend = self.backend.lock().await;
        backend.is_loaded()
    }
    
    /// Generate text from a prompt
    pub async fn generate(&self, prompt: &str, config: &InferenceConfig) -> Result<String> {
        let backend = self.backend.lock().await;
        backend.generate(prompt, config).await
    }
    
    /// Generate multimodal response with text and optional image or audio
    pub async fn generate_multimodal(&self, prompt: &str, media_data: Option<&[u8]>, media_type: Option<&str>, config: &InferenceConfig) -> Result<String> {
        let backend = self.backend.lock().await;
        backend.generate_multimodal(prompt, media_data, media_type, config).await
    }
    
    /// Generate text with performance metrics
    pub async fn generate_with_metrics(&self, prompt: &str, config: &InferenceConfig) -> Result<(String, InferenceMetrics)> {
        let backend = self.backend.lock().await;
        backend.generate_with_metrics(prompt, config).await
    }
    
    /// Get the current backend name
    pub async fn backend_name(&self) -> String {
        let backend = self.backend.lock().await;
        backend.name().to_string()
    }
    
    /// Get the current backend type
    pub fn backend_type(&self) -> BackendType {
        self.backend_type
    }
    
    /// Switch to a different backend (requires reloading the model)
    pub async fn switch_backend(&mut self, backend_type: BackendType) -> Result<()> {
        warn!("Switching inference backend from {:?} to {:?}", self.backend_type, backend_type);
        
        let new_backend = Self::create_backend(backend_type)?;
        self.backend = Arc::new(Mutex::new(new_backend));
        self.backend_type = backend_type;
        
        info!("Backend switched successfully. Model needs to be reloaded.");
        Ok(())
    }
    
    /// Run a benchmark for the current Ollama backend
    pub async fn benchmark_backend(&self, prompt: &str, config: &InferenceConfig) -> Result<InferenceMetrics> {
        match self.generate_with_metrics(prompt, config).await {
            Ok((_, metrics)) => Ok(metrics),
            Err(e) => {
                warn!("Ollama benchmark failed: {}", e);
                Err(e)
            }
        }
    }
    
    
    /// Get system information about available backends
    pub fn get_system_info() -> String {
        let mut info = String::new();
        
        info.push_str("Inference Backend:\n");
        
        // Ollama availability (cross-platform, always available)
        info.push_str("- Ollama: Available (cross-platform, reliable)\n");
        
        info.push_str(&format!("\nCurrent platform: {} {}\n", 
            std::env::consts::OS, 
            std::env::consts::ARCH
        ));
        
        info.push_str("Backend: Ollama (cross-platform AI model management)\n");
        
        info
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[tokio::test]
    async fn test_ollama_backend() {
        let result = InferenceManager::new(BackendType::Ollama);
        
        // Should always create Ollama backend (cross-platform)
        match result {
            Ok(manager) => {
                let backend_name = manager.backend_name().await;
                assert_eq!(backend_name, "Ollama");
            }
            Err(e) => {
                println!("Ollama backend creation failed: {}", e);
                // This shouldn't happen as Ollama is always available
                panic!("Ollama backend should always be available");
            }
        }
    }
    
    #[test]
    fn test_system_info() {
        let info = InferenceManager::get_system_info();
        assert!(info.contains("Inference Backend"));
        assert!(info.contains("Ollama"));
    }
    
    #[test]
    fn test_ollama_availability() {
        let info = InferenceManager::get_system_info();
        assert!(info.contains("Ollama: Available"));
    }
}