Add support for groq (#25)

* Add support for groq

* Update README to include Groq as a supported provider

Author: leehuwuj

README.md

@@ -15,7 +15,7 @@
 Features:
  - [x] Translation: Translate inputted text to a target language.
  - [x] Local LLM: Use Ollama as local LLM (offline mode).
- - [x] Providers: OpenAI, Ollama, Gemini.
+ - [x] Providers: OpenAI, Ollama, Gemini, Groq.
  - [x] Hot key: Quickly translate a selected text via shortcut key (Currently is: `Cmd + E`)
  - [] Linux support.
  - [x] Windows support.

src-tauri/src/providers/base.rs

@@ -2,7 +2,7 @@ use std::future::Future;
 use tauri::AppHandle;
 use tauri_plugin_store::StoreBuilder;
 
-use super::{gemini::GeminiProvider, ollama::OllamaProvider, openai::OpenAIProvider};
+use super::{gemini::GeminiProvider, groq::GroqProvider, ollama::OllamaProvider, openai::OpenAIProvider};
 
 pub trait Provider {
     fn completion(&self, prompt: &str) -> impl Future<Output = Result<String, String>>;
@@ -12,6 +12,7 @@ pub enum ProviderEnum {
     OllamaProvider(OllamaProvider),
     OpenAIProvider(OpenAIProvider),
     GeminiProvider(GeminiProvider),
+    GroqProvider(GroqProvider),
 }
 
 impl Provider for ProviderEnum {
@@ -20,6 +21,7 @@ impl Provider for ProviderEnum {
             ProviderEnum::OllamaProvider(provider) => provider.completion(prompt).await,
             ProviderEnum::OpenAIProvider(provider) => provider.completion(prompt).await,
             ProviderEnum::GeminiProvider(provider) => provider.completion(prompt).await,
+            ProviderEnum::GroqProvider(provider) => provider.completion(prompt).await,
         }
     }
 }
@@ -57,6 +59,21 @@ pub fn get_provider(app_handler: AppHandle, provider: &str, model: &str) -> Prov
 
             ProviderEnum::GeminiProvider(GeminiProvider::new(Some(api_key), Some(model)))
         }
+        "groq" => {
+            let store = StoreBuilder::new(&app_handler, "store.bin")
+                .build()
+                .expect("Failed to build store");
+
+            let api_key_value = store
+                .get("LLM_API_KEY")
+                .expect("Failed to get API key from store");
+
+            let api_key = api_key_value
+                .as_str()
+                .expect("API key is not a valid string");
+
+            ProviderEnum::GroqProvider(GroqProvider::new(Some(api_key), Some(model)))
+        }
         _ => panic!("Invalid provider"),
     }
 }

src-tauri/src/providers/groq.rs

@@ -0,0 +1,92 @@
+use crate::providers::base::Provider;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize)]
+struct GroqChatCompletionRequest<'a> {
+    model: &'a str,
+    messages: Vec<GroqMessage<'a>>,
+}
+
+#[derive(Serialize)]
+struct GroqMessage<'a> {
+    role: &'a str,
+    content: &'a str,
+}
+
+#[derive(Deserialize, Debug)]
+struct GroqChatCompletionResponse {
+    choices: Vec<Choice>,
+}
+
+#[derive(Deserialize, Debug)]
+struct Choice {
+    message: Message,
+}
+
+#[derive(Deserialize, Debug)]
+struct Message {
+    content: String,
+}
+
+pub struct GroqProvider {
+    client: Client,
+    api_key: String,
+    model: String,
+}
+
+impl GroqProvider {
+    pub fn new(api_key: Option<&str>, model: Option<&str>) -> Self {
+        Self {
+            client: Client::new(),
+            api_key: api_key.unwrap_or("").to_string(),
+            model: model.unwrap_or("llama-3.1-8b-instant").to_string(),
+        }
+    }
+}
+
+impl Provider for GroqProvider {
+    async fn completion(&self, prompt: &str) -> Result<String, String> {
+        let url = "https://api.groq.com/openai/v1/chat/completions";
+        
+        let messages = vec![GroqMessage {
+            role: "user",
+            content: prompt,
+        }];
+
+        let body = GroqChatCompletionRequest {
+            model: &self.model,
+            messages,
+        };
+
+        let res = self
+            .client
+            .post(url)
+            .bearer_auth(&self.api_key)
+            .json(&body)
+            .send()
+            .await;
+
+        match res {
+            Ok(res) => {
+                if res.status().is_success() {
+                    let response_body = res.json::<GroqChatCompletionResponse>().await;
+                    match response_body {
+                        Ok(data) => {
+                            if let Some(choice) = data.choices.get(0) {
+                                Ok(choice.message.content.clone())
+                            } else {
+                                Err("No content in Groq response".to_string())
+                            }
+                        }
+                        Err(err) => Err(format!("Failed to deserialize Groq response: {}", err)),
+                    }
+                } else {
+                    let error_text = res.text().await.unwrap_or_else(|e| e.to_string());
+                    Err(format!("Groq API request failed: {}", error_text))
+                }
+            }
+            Err(err) => Err(err.to_string()),
+        }
+    }
+} 

src-tauri/src/providers/mod.rs

@@ -1,4 +1,5 @@
 pub mod base;
 pub mod gemini;
+pub mod groq;
 pub mod ollama;
 pub mod openai;

src/app/sections/settings.tsx

@@ -103,6 +103,9 @@ const Settings = ({
                     <SelectItem key="gemini">
                       Gemini
                     </SelectItem>
+                    <SelectItem key="groq">
+                      Groq
+                    </SelectItem>
                   </Select>
                   <Select
                     label="Model"

src/app/types/settings.ts

@@ -14,7 +14,12 @@ export const providerMap: Record<string, Provider> = {
   gemini: {
     name: "gemini",
     label: "Gemini",
-    models: ["gemini-2.0-flash-lite", "gemini-2.5-flash"],
+    models: ["gemini-pro", "gemini-1.5-flash-latest"],
+  },
+  groq: {
+    name: "groq",
+    label: "Groq",
+    models: ["llama-3.1-8b-instant", "gemma2-9b-it"],
   },
 };