google gemini support

Author: scottleedavis

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "rattlebrain"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 authors = ["Scott Davis <scottleedavis@gmail.com>"]
-description = "A Rocket League replay analyzer using Multiple AI agents"
+description = "A Rocket League replay analyzer using Multiple AI agents (supports OpenAI, Antrhopic and Gemini)"
 license = "MIT"
 repository = "https://github.com/scottleedavis/rattlebrain"
 

README.md

@@ -17,7 +17,7 @@ also see the current [TODOs](TODO.md) for upcoming features.
 ## Features
 
 - **AI-Enhanced Analysis**: Analyze Rocket League replay files with the help of AI services for in-depth insights.
-- **Dynamic AI Selection**: Automatically detects and configures available AI services via environment variables (e.g., `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`).
+- **Dynamic AI Selection**: Automatically detects and configures available AI services via environment variables (e.g., `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`).
 - **Unified Reporting**: Combines outputs from multiple AI agents into a single, comprehensive report.
 - **Tactical Insights**: Highlights key plays, strategic opportunities, and areas for improvement.
 - **Performance Metrics**: Extracts useful data points to track your progress over time.
@@ -35,10 +35,11 @@ also see the current [TODOs](TODO.md) for upcoming features.
    - Get API keys for the AI services you'd like to use (e.g., OpenAI, Claude).
 
 3. Set Environment Variables:
-   - Add your API keys to your environment variables:
+   - Add API keys to AI Services in environment variables (at least 1):
      ```bash
      export OPENAI_API_KEY=<your_openai_api_key>
      export ANTHROPIC_API_KEY=<your_anthropic_api_key>
+     export GEMINI_API_KEY=<your_google_gemini_api_key>
      ```
 
 ---

src/ai/google.rs

@@ -0,0 +1,94 @@
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::env;
+use std::error::Error;
+
+#[derive(Debug, Serialize)]
+struct GeminiRequest {
+    contents: Vec<Content>,
+}
+
+#[derive(Debug, Serialize, Deserialize)] // Added Deserialize for request and response
+struct Content {
+    parts: Vec<Part>,
+}
+
+#[derive(Debug, Serialize, Deserialize)] // Added Deserialize for request and response
+struct Part {
+    text: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct GeminiResponse {
+    candidates: Vec<Candidate>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Candidate {
+    content: Content,
+}
+
+/// Sends a query to Gemini AI and returns the response.
+///
+/// # Arguments
+/// * `prompt` - The prompt string to send to Gemini.
+///
+/// # Returns
+/// A `Result` containing the response string, or an error if the request fails.
+pub async fn query_gemini(prompt: &str) -> Result<String, Box<dyn Error>> {
+    // Retrieve the API key from the environment
+    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY must be set");
+
+    // API URL
+    let base_url = format!(
+        "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key={}",
+        api_key
+    );
+
+    // Prepare the request body
+    let request_body = GeminiRequest {
+        contents: vec![Content {
+            parts: vec![Part {
+                text: prompt.to_string(),
+            }],
+        }],
+    };
+
+    // Initialize HTTP client
+    let client = Client::new();
+
+    // Send the request
+    let response = client
+        .post(&base_url)
+        .header("Content-Type", "application/json")
+        .json(&request_body)
+        .send()
+        .await?;
+
+    // Extract status and response text for debugging
+    let status = response.status();
+    let response_text = response.text().await.unwrap_or_else(|_| "Unknown error".to_string());
+
+    if status.is_success() {
+        // eprintln!("Successful response: {}", response_text); // Debugging raw response
+        // Parse the response JSON
+        let response_body: GeminiResponse = serde_json::from_str(&response_text)?;
+
+        // Extract and concatenate text from the candidate's content parts
+        let output = response_body
+            .candidates
+            .into_iter()
+            .flat_map(|candidate| candidate.content.parts)
+            .map(|part| part.text)
+            .collect::<Vec<String>>()
+            .join("\n");
+
+        Ok(output)
+    } else {
+        eprintln!("Failed response: {}", response_text); // Debugging raw error response
+        Err(Box::new(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("Request failed with status: {} - {}", status, response_text),
+        )))
+    }
+}

src/ai/mod.rs

@@ -1,2 +1,3 @@
 pub mod openai;
 pub mod anthropic;
+pub mod google;

src/query.rs

@@ -1,5 +1,6 @@
 use crate::ai::openai;
 use crate::ai::anthropic;
+use crate::ai::google;
 
 use std::fs;
 use std::env;
@@ -117,20 +118,11 @@ pub async fn query_ai(match_guid: &str, focus: &str) -> io::Result<String> {
 
     // Gemini
     if let Ok(gemini_key) = env::var("GEMINI_API_KEY") {
-        println!("Using Gemini with key: {}", &gemini_key[0..4]);
-        responses.push(format!(
-            "Gemini response to '{}': [This is a stubbed response from Gemini]",
-            query
-        ));
-    }
-
-    // GitHub Copilot
-    if let Ok(copilot_key) = env::var("COPILOT_API_KEY") {
-        println!("Using GitHub Copilot with key: {}", &copilot_key[0..4]);
-        responses.push(format!(
-            "GitHub Copilot response to '{}': [This is a stubbed response from Copilot]",
-            query
-        ));
+        println!("Using Google with key: {}****", &gemini_key[0..8]);
+        match google::query_gemini(&query).await {
+            Ok(response) => responses.push(format!("## Gemini response\n\n {}", response)),
+            Err(e) => eprintln!("Error querying Gemini: {}", e),
+        }
     }
 
     // Handle case where no providers are configured