feat:(first commit)created repository and complete 0.1.0

src/llm/ollama.rs

@@ -0,0 +1,206 @@
+use super::{create_http_client, LlmProvider};
+use anyhow::{Context, Result};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+/// Ollama API client
+pub struct OllamaClient {
+    base_url: String,
+    model: String,
+    client: reqwest::Client,
+}
+
+#[derive(Debug, Serialize)]
+struct GenerateRequest {
+    model: String,
+    prompt: String,
+    system: Option<String>,
+    stream: bool,
+    options: GenerationOptions,
+}
+
+#[derive(Debug, Serialize, Default)]
+struct GenerationOptions {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    num_predict: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GenerateResponse {
+    response: String,
+    done: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct ListModelsResponse {
+    models: Vec<ModelInfo>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ModelInfo {
+    name: String,
+}
+
+impl OllamaClient {
+    /// Create new Ollama client
+    pub fn new(base_url: &str, model: &str) -> Self {
+        let client = create_http_client(Duration::from_secs(120))
+            .expect("Failed to create HTTP client");
+        
+        Self {
+            base_url: base_url.trim_end_matches('/').to_string(),
+            model: model.to_string(),
+            client,
+        }
+    }
+
+    /// Set timeout
+    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+        self.client = create_http_client(timeout)
+            .expect("Failed to create HTTP client");
+        self
+    }
+
+    /// List available models
+    pub async fn list_models(&self) -> Result<Vec<String>> {
+        let url = format!("{}/api/tags", self.base_url);
+        
+        let response = self.client
+            .get(&url)
+            .send()
+            .await
+            .context("Failed to list Ollama models")?;
+        
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Ollama API error: {} - {}", status, text);
+        }
+        
+        let result: ListModelsResponse = response
+            .json()
+            .await
+            .context("Failed to parse Ollama response")?;
+        
+        Ok(result.models.into_iter().map(|m| m.name).collect())
+    }
+
+    /// Pull a model
+    pub async fn pull_model(&self, model: &str) -> Result<()> {
+        let url = format!("{}/api/pull", self.base_url);
+        
+        let request = serde_json::json!({
+            "name": model,
+            "stream": false,
+        });
+        
+        let response = self.client
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to pull Ollama model")?;
+        
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Ollama pull error: {} - {}", status, text);
+        }
+        
+        Ok(())
+    }
+
+    /// Check if model exists
+    pub async fn model_exists(&self, model: &str) -> bool {
+        match self.list_models().await {
+            Ok(models) => models.contains(&model.to_string()),
+            Err(_) => false,
+        }
+    }
+}
+
+#[async_trait]
+impl LlmProvider for OllamaClient {
+    async fn generate(&self, prompt: &str) -> Result<String> {
+        self.generate_with_system("", prompt).await
+    }
+
+    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
+        let url = format!("{}/api/generate", self.base_url);
+        
+        let system = if system.is_empty() {
+            None
+        } else {
+            Some(system.to_string())
+        };
+        
+        let request = GenerateRequest {
+            model: self.model.clone(),
+            prompt: user.to_string(),
+            system,
+            stream: false,
+            options: GenerationOptions {
+                temperature: Some(0.7),
+                num_predict: Some(500),
+            },
+        };
+        
+        let response = self.client
+            .post(&url)
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to send request to Ollama")?;
+        
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            anyhow::bail!("Ollama API error: {} - {}", status, text);
+        }
+        
+        let result: GenerateResponse = response
+            .json()
+            .await
+            .context("Failed to parse Ollama response")?;
+        
+        Ok(result.response.trim().to_string())
+    }
+
+    async fn is_available(&self) -> bool {
+        let url = format!("{}/api/tags", self.base_url);
+        
+        match self.client.get(&url).send().await {
+            Ok(response) => response.status().is_success(),
+            Err(_) => false,
+        }
+    }
+
+    fn name(&self) -> &str {
+        "ollama"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // These tests require a running Ollama server
+    #[tokio::test]
+    #[ignore]
+    async fn test_ollama_connection() {
+        let client = OllamaClient::new("http://localhost:11434", "llama2");
+        assert!(client.is_available().await);
+    }
+
+    #[tokio::test]
+    #[ignore]
+    async fn test_ollama_generate() {
+        let client = OllamaClient::new("http://localhost:11434", "llama2");
+        let response = client.generate("Hello, how are you?").await;
+        assert!(response.is_ok());
+        println!("Response: {}", response.unwrap());
+    }
+}