Struct Gemini 

pub struct Gemini { /* private fields */ }

Client for the Gemini API

Implementations

impl Gemini

pub fn new(api_key: impl Into<String>) -> Self

Create a new client with the specified API key

Examples found in repository

examples/test_api.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("GEMINI_API_KEY")?;

    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::new(api_key);

    println!("Sending request to Gemini API...");

    // Simple text completion with minimal content
    let response = client
        .generate_content()
        .with_user_message("Say hello")
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/google_search.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Google Search tool example ---");

    // Create a Google Search tool
    let google_search_tool = Tool::google_search();

    // Create a request with Google Search tool
    let response = client
        .generate_content()
        .with_user_message("What is the current Google stock price?")
        .with_tool(google_search_tool)
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/batch_list.rs (line 21)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get the API key from the environment
    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY not set");

    // Create a new Gemini client
    let gemini = Gemini::new(api_key);

    println!("Listing all batch operations...");

    // List all batch operations using the stream
    let stream = gemini.list_batches(5); // page_size of 5
    tokio::pin!(stream);

    while let Some(result) = stream.next().await {
        match result {
            Ok(operation) => {
                println!(
                    "  - Batch: {}, State: {:?}, Created: {}",
                    operation.name, operation.metadata.state, operation.metadata.create_time
                );
            }
            Err(e) => {
                eprintln!("Error fetching batch operation: {}", e);
            }
        }
    }

    println!("\nFinished listing operations.");

    Ok(())
}

examples/blob.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Image file path (in the same directory)
    let image_path = Path::new(file!())
        .parent()
        .unwrap_or(Path::new("."))
        .join("image-example.webp"); // Replace with your image filename

    // Read the image file
    let mut file = File::open(&image_path)?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;

    // Convert to base64
    let data = general_purpose::STANDARD.encode(&buffer);

    println!("Image loaded: {}", image_path.display());

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Describe Image ---");
    let response = client
        .generate_content()
        .with_inline_data(data, "image/webp")
        .with_response_mime_type("text/plain")
        .with_generation_config(GenerationConfig {
            temperature: Some(0.7),
            max_output_tokens: Some(400),
            ..Default::default()
        })
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/batch_delete.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get the API key from the environment
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY not set");

    // Get the batch name from the environment
    let batch_name = env::var("BATCH_NAME").expect("BATCH_NAME not set");

    // Create a new Gemini client
    let gemini = Gemini::new(api_key);

    // Get the batch operation
    let batch = gemini.get_batch(&batch_name);

    // Check the batch status
    match batch.status().await {
        Ok(status) => {
            println!("Batch status: {:?}", status);

            // Only delete completed batches (succeeded, failed, cancelled, or expired)
            match status {
                BatchStatus::Succeeded { .. } | BatchStatus::Cancelled | BatchStatus::Expired => {
                    println!("Deleting batch operation...");
                    // We need to handle the std::result::Result<(), (Batch, Error)> return type
                    match batch.delete().await {
                        Ok(()) => println!("Batch deleted successfully!"),
                        Err((_batch, e)) => {
                            println!("Failed to delete batch: {}. You can retry with the returned batch.", e);
                            // Here you could retry: batch.delete().await, etc.
                        }
                    }
                }
                _ => {
                    println!("Batch is still running or pending. Use cancel() to stop it, or wait for completion before deleting.");
                }
            }
        }
        Err(e) => println!("Failed to get batch status: {}", e),
    }

    Ok(())
}

examples/curl_google_search.rs (line 30)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    println!("--- Curl equivalent with Google Search tool ---");

    // This is equivalent to the curl example:
    // curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    //   -H "Content-Type: application/json" \
    //   -d '{
    //       "contents": [
    //           {
    //               "parts": [
    //                   {"text": "What is the current Google stock price?"}
    //               ]
    //           }
    //       ],
    //       "tools": [
    //           {
    //               "google_search": {}
    //           }
    //       ]
    //   }'

    // Create client
    let client = Gemini::new(api_key);

    // Create a content part that matches the JSON in the curl example
    let text_part = Part::Text {
        text: "What is the current Google stock price?".to_string(),
        thought: None,
    };

    let content = Content {
        parts: vec![text_part].into(),
        role: None,
    };

    // Create a Google Search tool
    let google_search_tool = Tool::google_search();

    // Add the content and tool directly to the request
    // This exactly mirrors the JSON structure in the curl example
    let mut content_builder = client.generate_content();
    content_builder.contents.push(content);
    content_builder = content_builder.with_tool(google_search_tool);

    let response = content_builder.execute().await?;

    println!("Response: {}", response.text());

    Ok(())
}

Additional examples can be found in:

• examples/curl_equivalent.rs
• examples/generation_config.rs
• examples/structured_response.rs
• examples/streaming.rs
• examples/batch_generate.rs
• examples/advanced.rs
• examples/simple.rs
• examples/google_search_with_functions.rs
• examples/batch_cancel.rs
• examples/tools.rs

pub fn pro(api_key: impl Into<String>) -> Self

Create a new client for the Gemini Pro model

Examples found in repository

examples/gemini_pro_example.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Replace with your actual API key
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Create a Gemini client
    let gemini = Gemini::pro(api_key);

    // This example matches the exact curl request format:
    // curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    //   -H 'Content-Type: application/json' \
    //   -d '{
    //     "system_instruction": {
    //       "parts": [
    //         {
    //           "text": "You are a cat. Your name is Neko."
    //         }
    //       ]
    //     },
    //     "contents": [
    //       {
    //         "parts": [
    //           {
    //             "text": "Hello there"
    //           }
    //         ]
    //       }
    //     ]
    //   }'
    let response = gemini
        .generate_content()
        .with_system_instruction("You are a cat. Your name is Neko.")
        .with_user_message("Hello there")
        .execute()
        .await?;

    // Print the response
    println!("Response: {}", response.text());

    Ok(())
}

examples/mp4_describe.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Read mp4 video file
    let mut file = File::open("examples/sample.mp4")?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;
    let b64 = general_purpose::STANDARD.encode(&buffer);

    // Get API key
    let api_key = env::var("GEMINI_API_KEY")?;
    let gemini = Gemini::pro(api_key);

    // Example 1: Add mp4 blob using Message struct
    let video_content = Content::inline_data("video/mp4", b64.clone());
    let response1 = gemini
        .generate_content()
        .with_user_message("Please describe the content of this video (Message example)")
        .with_message(gemini_rust::Message {
            content: video_content,
            role: gemini_rust::Role::User,
        })
        .execute()
        .await?;

    println!("AI description (Message): {}", response1.text());

    // Example 2: Add mp4 blob directly using builder's with_inline_data
    let response2 = gemini
        .generate_content()
        .with_user_message("Please describe the content of this video (with_inline_data example)")
        .with_inline_data(b64, "video/mp4")
        .execute()
        .await?;

    println!("AI description (with_inline_data): {}", response2.text());
    Ok(())
}

pub fn with_model(api_key: impl Into<String>, model: String) -> Self

Create a new client with the specified API key and model

Examples found in repository

examples/embedding.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GEMINI_API_KEY")?;

    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::with_model(api_key, "models/text-embedding-004".to_string());

    println!("Sending embedding request to Gemini API...");

    // Simple text embedding
    let response = client
        .embed_content()
        .with_text("Hello")
        .with_task_type(TaskType::RetrievalDocument)
        .execute()
        .await?;

    println!("Response: {:?}", response.embedding.values);

    Ok(())
}

examples/batch_embedding.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GEMINI_API_KEY")?;

    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::with_model(api_key, "models/text-embedding-004".to_string());

    println!("Sending batch embedding request to Gemini API...");

    // Simple text embedding
    let response = client
        .embed_content()
        .with_chunks(vec!["Hello", "World", "Test embedding 3"])
        .with_task_type(TaskType::RetrievalDocument)
        .execute_batch()
        .await?;

    println!("Response: ");
    for (i, e) in response.embeddings.iter().enumerate() {
        println!("|{}|: {:?}\n", i, e.values);
    }

    Ok(())
}

examples/thinking_basic.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::with_model(api_key, "models/gemini-2.5-pro".to_string());

    println!("=== Gemini 2.5 Thinking Basic Example ===\n");

    // Example 1: Using default dynamic thinking
    println!(
        "--- Example 1: Dynamic thinking (model automatically determines thinking budget) ---"
    );
    let response1 = client
        .generate_content()
        .with_system_prompt("You are a helpful mathematics assistant.")
        .with_user_message(
            "Explain Occam's razor principle and provide a simple example from daily life.",
        )
        .with_dynamic_thinking()
        .with_thoughts_included(true)
        .execute()
        .await?;

    // Display thinking process
    let thoughts = response1.thoughts();
    if !thoughts.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    println!("Answer: {}\n", response1.text());

    // Display token usage
    if let Some(usage) = &response1.usage_metadata {
        println!("Token usage:");
        println!("  Prompt tokens: {}", usage.prompt_token_count);
        println!(
            "  Response tokens: {}",
            usage.candidates_token_count.unwrap_or(0)
        );
        if let Some(thinking_tokens) = usage.thoughts_token_count {
            println!("  Thinking tokens: {}", thinking_tokens);
        }
        println!("  Total tokens: {}\n", usage.total_token_count);
    }

    // Example 2: Set specific thinking budget
    println!("--- Example 2: Set thinking budget (1024 tokens) ---");
    let response2 = client
        .generate_content()
        .with_system_prompt("You are a helpful programming assistant.")
        .with_user_message("List 3 main advantages of using the Rust programming language")
        .with_thinking_budget(1024)
        .with_thoughts_included(true)
        .execute()
        .await?;

    // Display thinking process
    let thoughts2 = response2.thoughts();
    if !thoughts2.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts2.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    println!("Answer: {}\n", response2.text());

    // Example 3: Disable thinking feature
    println!("--- Example 3: Disable thinking feature ---");
    let response3 = client
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("What is artificial intelligence?")
        .execute()
        .await?;

    println!("Answer: {}\n", response3.text());

    // Example 4: Use GenerationConfig to set thinking
    println!("--- Example 4: Use GenerationConfig to set thinking ---");
    let thinking_config = ThinkingConfig::new()
        .with_thinking_budget(2048)
        .with_thoughts_included(true);

    let generation_config = GenerationConfig {
        temperature: Some(0.7),
        max_output_tokens: Some(500),
        thinking_config: Some(thinking_config),
        ..Default::default()
    };

    let response4 = client
        .generate_content()
        .with_system_prompt("You are a creative writing assistant.")
        .with_user_message(
            "Write the opening of a short story about a robot learning to feel emotions.",
        )
        .with_generation_config(generation_config)
        .execute()
        .await?;

    // Display thinking process
    let thoughts4 = response4.thoughts();
    if !thoughts4.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts4.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    println!("Answer: {}\n", response4.text());

    Ok(())
}

examples/thinking_curl_equivalent.rs (line 33)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // This is equivalent to the following curl example:
    // curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent" \
    //   -H "x-goog-api-key: $GEMINI_API_KEY" \
    //   -H 'Content-Type: application/json' \
    //   -X POST \
    //   -d '{
    //     "contents": [
    //       {
    //         "parts": [
    //           {
    //             "text": "Provide a list of the top 3 famous physicists and their major contributions"
    //           }
    //         ]
    //       }
    //     ],
    //     "generationConfig": {
    //       "thinkingConfig": {
    //         "thinkingBudget": 1024,
    //         "includeThoughts": true
    //       }
    //     }
    //   }'

    // Create client
    let client = Gemini::with_model(api_key, "models/gemini-2.5-pro".to_string());

    println!("=== Thinking Curl Equivalent Example ===\n");

    // Method 1: Using high-level API (simplest approach)
    println!("--- Method 1: Using high-level API ---");

    let response1 = client
        .generate_content()
        .with_user_message(
            "Provide a list of the top 3 famous physicists and their major contributions",
        )
        .with_thinking_budget(1024)
        .with_thoughts_included(true)
        .execute()
        .await?;

    // Display thinking process
    let thoughts1 = response1.thoughts();
    if !thoughts1.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts1.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    println!("Answer: {}\n", response1.text());

    // Method 2: Using GenerationConfig to fully match curl example structure
    println!("--- Method 2: Fully matching curl example structure ---");

    let thinking_config = ThinkingConfig {
        thinking_budget: Some(1024),
        include_thoughts: Some(true),
    };

    let generation_config = GenerationConfig {
        thinking_config: Some(thinking_config),
        ..Default::default()
    };

    let response2 = client
        .generate_content()
        .with_user_message(
            "Provide a list of the top 3 famous physicists and their major contributions",
        )
        .with_generation_config(generation_config)
        .execute()
        .await?;

    // Display thinking process
    let thoughts2 = response2.thoughts();
    if !thoughts2.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts2.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    println!("Answer: {}\n", response2.text());

    // Show token usage
    if let Some(usage) = &response2.usage_metadata {
        println!("Token usage:");
        println!("  Prompt tokens: {}", usage.prompt_token_count);
        println!(
            "  Response tokens: {}",
            usage.candidates_token_count.unwrap_or(0)
        );
        if let Some(thinking_tokens) = usage.thoughts_token_count {
            println!("  Thinking tokens: {}", thinking_tokens);
        }
        println!("  Total tokens: {}", usage.total_token_count);
    }

    // Method 3: Demonstrate different thinking budget settings
    println!("\n--- Method 3: Different thinking budget comparison ---");

    // Thinking disabled
    println!("Thinking disabled:");
    let response_no_thinking = client
        .generate_content()
        .with_user_message("Explain the basic principles of quantum mechanics")
        .execute()
        .await?;
    println!("Answer: {}\n", response_no_thinking.text());

    // Dynamic thinking
    println!("Dynamic thinking:");
    let response_dynamic = client
        .generate_content()
        .with_user_message("Explain the basic principles of quantum mechanics")
        .with_dynamic_thinking()
        .with_thoughts_included(true)
        .execute()
        .await?;

    let thoughts_dynamic = response_dynamic.thoughts();
    if !thoughts_dynamic.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts_dynamic.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }
    println!("Answer: {}\n", response_dynamic.text());

    // High thinking budget
    println!("High thinking budget (4096 tokens):");
    let response_high_budget = client
        .generate_content()
        .with_user_message("Explain the basic principles of quantum mechanics")
        .with_thinking_budget(4096)
        .with_thoughts_included(true)
        .execute()
        .await?;

    let thoughts_high = response_high_budget.thoughts();
    if !thoughts_high.is_empty() {
        println!("Thinking summary:");
        for (i, thought) in thoughts_high.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }
    println!("Answer: {}", response_high_budget.text());

    Ok(())
}

examples/thinking_advanced.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::with_model(api_key, "models/gemini-2.5-pro".to_string());

    println!("=== Gemini 2.5 Thinking Advanced Example ===\n");

    // Example 1: Streaming with thinking
    println!("--- Example 1: Streaming with thinking ---");
    let mut stream = client
        .generate_content()
        .with_system_prompt("You are a mathematics expert skilled at solving complex mathematical problems.")
        .with_user_message("Solve this math problem: Find the sum of the first 50 prime numbers. Please explain your solution process in detail.")
        .with_thinking_budget(2048)
        .with_thoughts_included(true)
        .execute_stream()
        .await?;

    println!("Streaming response:");
    let mut thoughts_shown = false;
    while let Some(chunk_result) = stream.next().await {
        match chunk_result {
            Ok(chunk) => {
                // Check if there's thinking content
                let thoughts = chunk.thoughts();
                if !thoughts.is_empty() && !thoughts_shown {
                    println!("\nThinking process:");
                    for (i, thought) in thoughts.iter().enumerate() {
                        println!("Thought {}: {}", i + 1, thought);
                    }
                    println!("\nAnswer:");
                    thoughts_shown = true;
                }

                // Display general text content
                print!("{}", chunk.text());
                std::io::Write::flush(&mut std::io::stdout())?;
            }
            Err(e) => eprintln!("Streaming error: {}", e),
        }
    }
    println!("\n");

    // Example 2: Thinking combined with function calls
    println!("--- Example 2: Thinking combined with function calls ---");

    // Define a calculator function
    let calculator = FunctionDeclaration::new(
        "calculate",
        "Perform basic mathematical calculations",
        FunctionParameters::object()
            .with_property(
                "expression",
                PropertyDetails::string(
                    "The mathematical expression to calculate, e.g., '2 + 3 * 4'",
                ),
                true,
            )
            .with_property(
                "operation_type",
                PropertyDetails::enum_type("Type of calculation", ["arithmetic", "advanced"]),
                false,
            ),
    );

    let response = client
        .generate_content()
        .with_system_prompt("You are a mathematics assistant. When calculations are needed, use the provided calculator function.")
        .with_user_message("Calculate the result of (15 + 25) * 3 - 8 and explain the calculation steps.")
        .with_function(calculator)
        .with_thinking_budget(1024)
        .with_thoughts_included(true)
        .execute()
        .await?;

    // Display thinking process
    let thoughts = response.thoughts();
    if !thoughts.is_empty() {
        println!("Thinking process:");
        for (i, thought) in thoughts.iter().enumerate() {
            println!("Thought {}: {}\n", i + 1, thought);
        }
    }

    // Check for function calls
    let function_calls = response.function_calls();
    if !function_calls.is_empty() {
        println!("Function calls:");
        for (i, call) in function_calls.iter().enumerate() {
            println!("Call {}: {} Args: {}", i + 1, call.name, call.args);
        }
        println!();
    }

    println!("Answer: {}\n", response.text());

    // Example 3: Complex reasoning task
    println!("--- Example 3: Complex reasoning task ---");
    let complex_response = client
        .generate_content()
        .with_system_prompt("You are a logical reasoning expert.")
        .with_user_message(
            "There are three people: Alice, Bob, and Carol, who live in red, green, and blue houses respectively.\
            Given:\
            1. The person in the red house owns a cat\
            2. Bob does not live in the green house\
            3. Carol owns a dog\
            4. The green house is to the left of the red house\
            5. Alice does not own a cat\
            Please reason out which color house each person lives in and what pets they own.",
        )
        .with_thinking_config(
            ThinkingConfig::new()
                .with_thinking_budget(3072)
                .with_thoughts_included(true),
        )
        .execute()
        .await?;

    // Display thinking process
    let complex_thoughts = complex_response.thoughts();
    if !complex_thoughts.is_empty() {
        println!("Reasoning process:");
        for (i, thought) in complex_thoughts.iter().enumerate() {
            println!("Reasoning step {}: {}\n", i + 1, thought);
        }
    }

    println!("Conclusion: {}\n", complex_response.text());

    // Display token usage statistics
    if let Some(usage) = &complex_response.usage_metadata {
        println!("Token usage statistics:");
        println!("  Prompt tokens: {}", usage.prompt_token_count);
        println!(
            "  Response tokens: {}",
            usage.candidates_token_count.unwrap_or(0)
        );
        if let Some(thinking_tokens) = usage.thoughts_token_count {
            println!("  Thinking tokens: {}", thinking_tokens);
        }
        println!("  Total tokens: {}", usage.total_token_count);
    }

    Ok(())
}

pub fn with_base_url(api_key: impl Into<String>, base_url: String) -> Self

Create a new client with custom base URL

pub fn with_model_and_base_url( api_key: impl Into<String>, model: String, base_url: String, ) -> Self

Create a new client with the specified API key, model, and base URL

Examples found in repository

examples/custom_base_url.rs (lines 10-14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");
    // Using custom base URL
    let custom_base_url = "https://generativelanguage.googleapis.com/v1beta/";
    let client_custom = Gemini::with_model_and_base_url(
        api_key,
        "models/gemini-2.5-flash-lite-preview-06-17".to_string(),
        custom_base_url.to_string(),
    );
    println!("Custom base URL client created successfully");
    let response = client_custom
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("Hello, can you tell me a joke about programming?")
        .with_generation_config(GenerationConfig {
            temperature: Some(0.7),
            max_output_tokens: Some(100),
            ..Default::default()
        })
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

pub fn generate_content(&self) -> ContentBuilder

Start building a content generation request

Examples found in repository

examples/test_api.rs (line 15)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("GEMINI_API_KEY")?;

    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::new(api_key);

    println!("Sending request to Gemini API...");

    // Simple text completion with minimal content
    let response = client
        .generate_content()
        .with_user_message("Say hello")
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/google_search.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Google Search tool example ---");

    // Create a Google Search tool
    let google_search_tool = Tool::google_search();

    // Create a request with Google Search tool
    let response = client
        .generate_content()
        .with_user_message("What is the current Google stock price?")
        .with_tool(google_search_tool)
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/custom_base_url.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");
    // Using custom base URL
    let custom_base_url = "https://generativelanguage.googleapis.com/v1beta/";
    let client_custom = Gemini::with_model_and_base_url(
        api_key,
        "models/gemini-2.5-flash-lite-preview-06-17".to_string(),
        custom_base_url.to_string(),
    );
    println!("Custom base URL client created successfully");
    let response = client_custom
        .generate_content()
        .with_system_prompt("You are a helpful assistant.")
        .with_user_message("Hello, can you tell me a joke about programming?")
        .with_generation_config(GenerationConfig {
            temperature: Some(0.7),
            max_output_tokens: Some(100),
            ..Default::default()
        })
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/gemini_pro_example.rs (line 35)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Replace with your actual API key
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Create a Gemini client
    let gemini = Gemini::pro(api_key);

    // This example matches the exact curl request format:
    // curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    //   -H 'Content-Type: application/json' \
    //   -d '{
    //     "system_instruction": {
    //       "parts": [
    //         {
    //           "text": "You are a cat. Your name is Neko."
    //         }
    //       ]
    //     },
    //     "contents": [
    //       {
    //         "parts": [
    //           {
    //             "text": "Hello there"
    //           }
    //         ]
    //       }
    //     ]
    //   }'
    let response = gemini
        .generate_content()
        .with_system_instruction("You are a cat. Your name is Neko.")
        .with_user_message("Hello there")
        .execute()
        .await?;

    // Print the response
    println!("Response: {}", response.text());

    Ok(())
}

examples/blob.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get API key from environment variable
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");

    // Image file path (in the same directory)
    let image_path = Path::new(file!())
        .parent()
        .unwrap_or(Path::new("."))
        .join("image-example.webp"); // Replace with your image filename

    // Read the image file
    let mut file = File::open(&image_path)?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;

    // Convert to base64
    let data = general_purpose::STANDARD.encode(&buffer);

    println!("Image loaded: {}", image_path.display());

    // Create client
    let client = Gemini::new(api_key);

    println!("--- Describe Image ---");
    let response = client
        .generate_content()
        .with_inline_data(data, "image/webp")
        .with_response_mime_type("text/plain")
        .with_generation_config(GenerationConfig {
            temperature: Some(0.7),
            max_output_tokens: Some(400),
            ..Default::default()
        })
        .execute()
        .await?;

    println!("Response: {}", response.text());

    Ok(())
}

examples/mp4_describe.rs (line 25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Read mp4 video file
    let mut file = File::open("examples/sample.mp4")?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;
    let b64 = general_purpose::STANDARD.encode(&buffer);

    // Get API key
    let api_key = env::var("GEMINI_API_KEY")?;
    let gemini = Gemini::pro(api_key);

    // Example 1: Add mp4 blob using Message struct
    let video_content = Content::inline_data("video/mp4", b64.clone());
    let response1 = gemini
        .generate_content()
        .with_user_message("Please describe the content of this video (Message example)")
        .with_message(gemini_rust::Message {
            content: video_content,
            role: gemini_rust::Role::User,
        })
        .execute()
        .await?;

    println!("AI description (Message): {}", response1.text());

    // Example 2: Add mp4 blob directly using builder's with_inline_data
    let response2 = gemini
        .generate_content()
        .with_user_message("Please describe the content of this video (with_inline_data example)")
        .with_inline_data(b64, "video/mp4")
        .execute()
        .await?;

    println!("AI description (with_inline_data): {}", response2.text());
    Ok(())
}

Additional examples can be found in:

• examples/curl_google_search.rs
• examples/curl_equivalent.rs
• examples/generation_config.rs
• examples/structured_response.rs
• examples/streaming.rs
• examples/batch_generate.rs
• examples/advanced.rs
• examples/simple.rs
• examples/thinking_basic.rs
• examples/google_search_with_functions.rs
• examples/batch_cancel.rs
• examples/thinking_curl_equivalent.rs
• examples/thinking_advanced.rs
• examples/tools.rs

pub fn embed_content(&self) -> EmbedBuilder

Start building a content generation request

Examples found in repository

examples/embedding.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GEMINI_API_KEY")?;

    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::with_model(api_key, "models/text-embedding-004".to_string());

    println!("Sending embedding request to Gemini API...");

    // Simple text embedding
    let response = client
        .embed_content()
        .with_text("Hello")
        .with_task_type(TaskType::RetrievalDocument)
        .execute()
        .await?;

    println!("Response: {:?}", response.embedding.values);

    Ok(())
}

examples/batch_embedding.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GEMINI_API_KEY")?;

    // Create client with the default model (gemini-2.0-flash)
    let client = Gemini::with_model(api_key, "models/text-embedding-004".to_string());

    println!("Sending batch embedding request to Gemini API...");

    // Simple text embedding
    let response = client
        .embed_content()
        .with_chunks(vec!["Hello", "World", "Test embedding 3"])
        .with_task_type(TaskType::RetrievalDocument)
        .execute_batch()
        .await?;

    println!("Response: ");
    for (i, e) in response.embeddings.iter().enumerate() {
        println!("|{}|: {:?}\n", i, e.values);
    }

    Ok(())
}

pub fn batch_generate_content_sync(&self) -> BatchBuilder

Start building a synchronous batch content generation request

Examples found in repository

examples/batch_generate.rs (line 39)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get the API key from the environment
    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY not set");

    // Create a new Gemini client
    let gemini = Gemini::new(api_key);

    // Create the first request
    let request1 = gemini
        .generate_content()
        .with_message(Message::user("What is the meaning of life?"))
        .build();

    // Create the second request
    let request2 = gemini
        .generate_content()
        .with_message(Message::user("What is the best programming language?"))
        .build();

    // Create the batch request
    let batch = gemini
        .batch_generate_content_sync()
        .with_request(request1)
        .with_request(request2)
        .execute()
        .await?;

    // Print the batch information
    println!("Batch created successfully!");
    println!("Batch Name: {}", batch.name());

    // Wait for the batch to complete
    println!("Waiting for batch to complete...");
    match batch.wait_for_completion(Duration::from_secs(5)).await {
        Ok(final_status) => {
            // Print the final status
            match final_status {
                BatchStatus::Succeeded { results } => {
                    println!("Batch succeeded!");
                    for item in results {
                        match item {
                            BatchResultItem::Success { key, response } => {
                                println!("--- Response for Key {} ---", key);
                                println!("{}", response.text());
                            }
                            BatchResultItem::Error { key, error } => {
                                println!("--- Error for Key {} ---", key);
                                println!("Code: {}, Message: {}", error.code, error.message);
                                if let Some(details) = &error.details {
                                    println!("Details: {}", details);
                                }
                            }
                        }
                    }
                }
                BatchStatus::Cancelled => {
                    println!("Batch was cancelled.");
                }
                BatchStatus::Expired => {
                    println!("Batch expired.");
                }
                _ => {
                    println!(
                        "Batch finished with an unexpected status: {:?}",
                        final_status
                    );
                }
            }
        }
        Err((_batch, e)) => {
            println!(
                "Batch failed: {}. You can retry with the returned batch.",
                e
            );
            // Here you could retry: batch.wait_for_completion(Duration::from_secs(5)).await, etc.
        }
    }

    Ok(())
}

examples/batch_cancel.rs (line 24)

async fn main() -> Result<()> {
    // Get the API key from the environment
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY must be set");

    // Create the Gemini client
    let gemini = Gemini::new(api_key);

    // Create a batch with multiple requests
    let mut batch_generate_content = gemini
        .batch_generate_content_sync()
        .with_name("batch_cancel_example".to_string());

    // Add several requests to make the batch take some time to process
    for i in 1..=10 {
        let request = gemini
            .generate_content()
            .with_message(Message::user(format!(
                "Write a creative story about a robot learning to paint, part {}. Make it at least 100 words long.",
                i
            )))
            .build();

        batch_generate_content = batch_generate_content.with_request(request);
    }

    // Build and start the batch
    let batch = batch_generate_content.execute().await?;
    println!("Batch created successfully!");
    println!("Batch Name: {}", batch.name());
    println!("Press CTRL-C to cancel the batch operation...");

    // Wrap the batch in an Arc<Mutex<Option<Batch>>> to allow safe sharing
    let batch = Arc::new(Mutex::new(Some(batch)));
    let batch_clone = Arc::clone(&batch);

    // Spawn a task to handle CTRL-C
    let cancel_task = tokio::spawn(async move {
        // Wait for CTRL-C signal
        signal::ctrl_c().await.expect("Failed to listen for CTRL-C");
        println!("Received CTRL-C, canceling batch operation...");

        // Take the batch from the Option, leaving None.
        // The lock is released immediately after this block.
        let mut batch_to_cancel = batch_clone.lock().await;

        if let Some(batch) = batch_to_cancel.take() {
            // Cancel the batch operation
            match batch.cancel().await {
                Ok(()) => {
                    println!("Batch canceled successfully!");
                }
                Err((batch, e)) => {
                    println!("Failed to cancel batch: {}. Retrying...", e);
                    // Retry once
                    match batch.cancel().await {
                        Ok(()) => {
                            println!("Batch canceled successfully on retry!");
                        }
                        Err((_, retry_error)) => {
                            eprintln!("Failed to cancel batch even on retry: {}", retry_error);
                        }
                    }
                }
            }
        } else {
            println!("Batch was already processed.");
        }
    });

    // Wait for a short moment to ensure the cancel task is ready
    tokio::time::sleep(Duration::from_millis(100)).await;

    // Wait for the batch to complete or be canceled
    if let Some(batch) = batch.lock().await.take() {
        println!("Waiting for batch to complete or be canceled...");
        match batch.wait_for_completion(Duration::from_secs(5)).await {
            Ok(final_status) => {
                // Cancel task is no longer needed since batch completed
                cancel_task.abort();

                println!("Batch completed with status: {:?}", final_status);

                // Print some details about the results
                match final_status {
                    gemini_rust::BatchStatus::Succeeded { .. } => {
                        println!("Batch succeeded!");
                    }
                    gemini_rust::BatchStatus::Cancelled => {
                        println!("Batch was cancelled as requested.");
                    }
                    gemini_rust::BatchStatus::Expired => {
                        println!("Batch expired.");
                    }
                    _ => {
                        println!("Batch finished with an unexpected status.");
                    }
                }
            }
            Err((batch, e)) => {
                // This could happen if there was a network error while polling
                println!("Error while waiting for batch completion: {}", e);

                // Try one more time to get the status
                match batch.status().await {
                    Ok(status) => println!("Current batch status: {:?}", status),
                    Err(status_error) => println!("Error getting final status: {}", status_error),
                }
            }
        }
    }

    Ok(())
}

pub fn get_batch(&self, name: &str) -> Batch

Get a handle to a batch operation by its name.

Examples found in repository

examples/batch_delete.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get the API key from the environment
    let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY not set");

    // Get the batch name from the environment
    let batch_name = env::var("BATCH_NAME").expect("BATCH_NAME not set");

    // Create a new Gemini client
    let gemini = Gemini::new(api_key);

    // Get the batch operation
    let batch = gemini.get_batch(&batch_name);

    // Check the batch status
    match batch.status().await {
        Ok(status) => {
            println!("Batch status: {:?}", status);

            // Only delete completed batches (succeeded, failed, cancelled, or expired)
            match status {
                BatchStatus::Succeeded { .. } | BatchStatus::Cancelled | BatchStatus::Expired => {
                    println!("Deleting batch operation...");
                    // We need to handle the std::result::Result<(), (Batch, Error)> return type
                    match batch.delete().await {
                        Ok(()) => println!("Batch deleted successfully!"),
                        Err((_batch, e)) => {
                            println!("Failed to delete batch: {}. You can retry with the returned batch.", e);
                            // Here you could retry: batch.delete().await, etc.
                        }
                    }
                }
                _ => {
                    println!("Batch is still running or pending. Use cancel() to stop it, or wait for completion before deleting.");
                }
            }
        }
        Err(e) => println!("Failed to get batch status: {}", e),
    }

    Ok(())
}

pub fn list_batches( &self, page_size: impl Into<Option<u32>>, ) -> impl Stream<Item = Result<BatchOperation>> + Send

Lists batch operations.

This method returns a stream that handles pagination automatically.

Examples found in repository

examples/batch_list.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get the API key from the environment
    let api_key = std::env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY not set");

    // Create a new Gemini client
    let gemini = Gemini::new(api_key);

    println!("Listing all batch operations...");

    // List all batch operations using the stream
    let stream = gemini.list_batches(5); // page_size of 5
    tokio::pin!(stream);

    while let Some(result) = stream.next().await {
        match result {
            Ok(operation) => {
                println!(
                    "  - Batch: {}, State: {:?}, Created: {}",
                    operation.name, operation.metadata.state, operation.metadata.create_time
                );
            }
            Err(e) => {
                eprintln!("Error fetching batch operation: {}", e);
            }
        }
    }

    println!("\nFinished listing operations.");

    Ok(())
}

Trait Implementations

impl Clone for Gemini

fn clone(&self) -> Gemini

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.