Struct LLMConfig 

pub struct LLMConfig {

    pub model: String,
    pub api_key: Option<String>,
    pub base_url: Option<String>,
    pub max_tokens: Option<u32>,
    pub temperature: Option<f32>,
    pub top_p: Option<f32>,
    pub top_k: Option<u32>,
    pub system: Option<String>,
    pub timeout_seconds: Option<u64>,
    pub embedding_encoding_format: Option<String>,
    pub embedding_dimensions: Option<u32>,
    pub enable_parallel_tool_use: Option<bool>,
    pub reasoning: Option<bool>,
    pub reasoning_effort: Option<String>,
    pub reasoning_budget_tokens: Option<u32>,
    pub api_version: Option<String>,
    pub deployment_id: Option<String>,
    pub voice: Option<String>,
    pub xai_search_mode: Option<String>,
    pub xai_search_source_type: Option<String>,
    pub xai_search_excluded_websites: Option<Vec<String>>,
    pub xai_search_max_results: Option<u32>,
    pub xai_search_from_date: Option<String>,
    pub xai_search_to_date: Option<String>,
    pub openai_enable_web_search: Option<bool>,
    pub openai_web_search_context_size: Option<String>,
    pub openai_web_search_user_location_type: Option<String>,
    pub openai_web_search_user_location_approximate_country: Option<String>,
    pub openai_web_search_user_location_approximate_city: Option<String>,
    pub openai_web_search_user_location_approximate_region: Option<String>,
    pub resilient_enable: Option<bool>,
    pub resilient_attempts: Option<usize>,
    pub resilient_base_delay_ms: Option<u64>,
    pub resilient_max_delay_ms: Option<u64>,
    pub resilient_jitter: Option<bool>,
}

Configuration for LLM providers with all builder options.

This struct provides comprehensive configuration for any LLM provider, matching all options available in the LLMBuilder.

Fields

model: String

api_key: Option<String>

base_url: Option<String>

max_tokens: Option<u32>

temperature: Option<f32>

top_p: Option<f32>

top_k: Option<u32>

system: Option<String>

timeout_seconds: Option<u64>

embedding_encoding_format: Option<String>

embedding_dimensions: Option<u32>

enable_parallel_tool_use: Option<bool>

reasoning: Option<bool>

reasoning_effort: Option<String>

reasoning_budget_tokens: Option<u32>

api_version: Option<String>

deployment_id: Option<String>

voice: Option<String>

xai_search_mode: Option<String>

xai_search_source_type: Option<String>

xai_search_excluded_websites: Option<Vec<String>>

xai_search_max_results: Option<u32>

xai_search_from_date: Option<String>

xai_search_to_date: Option<String>

openai_enable_web_search: Option<bool>

openai_web_search_context_size: Option<String>

openai_web_search_user_location_type: Option<String>

openai_web_search_user_location_approximate_country: Option<String>

openai_web_search_user_location_approximate_city: Option<String>

openai_web_search_user_location_approximate_region: Option<String>

resilient_enable: Option<bool>

resilient_attempts: Option<usize>

resilient_base_delay_ms: Option<u64>

resilient_max_delay_ms: Option<u64>

resilient_jitter: Option<bool>

Implementations

impl LLMConfig

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

Create a new LLMConfig with just the model name

Examples found in repository

examples/08_llm_providers.rs (line 173)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

/// Example 3: Provider-specific features
async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

/// Example 4: Compare providers
async fn compare_providers() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Comparing responses across providers:\n");

    let providers = vec![
        ("OpenAI GPT-4", "openai::gpt-4", std::env::var("OPENAI_API_KEY").ok()),
        ("Anthropic Claude", "anthropic::claude-3-sonnet-20240229", std::env::var("ANTHROPIC_API_KEY").ok()),
        ("Ollama Llama", "ollama::llama3.2", None),
        ("Google Gemini", "google::gemini-pro", std::env::var("GOOGLE_API_KEY").ok()),
        ("Groq Mixtral", "groq::mixtral-8x7b-32768", std::env::var("GROQ_API_KEY").ok()),
    ];

    for (name, model, api_key) in providers {
        println!("🤖 {}:", name);

        let mut agent = Agent::new(name, model);

        // Configure with LLMConfig if API key is available
        if let Some(key) = api_key {
            let config = LLMConfig::new(model)
                .with_api_key(key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            if let Ok(_) = agent.with_llm_config(config) {
                let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
                let response = agent.run(task).await;
                println!("   ✓ {:?}", response.result());
            }
        } else {
            // Try without explicit API key (for Ollama or env vars)
            let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
            let response = agent.run(task).await;
            println!("   ✓ {:?}", response.result());
        }

        println!();
    }

    Ok(())
}

examples/09_test_groq.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing Groq LLM Provider with API Key\n");

    // Test 1: Using Agent::new_with_config() - Recommended approach
    println!("{}", "=".repeat(60));
    println!("Test 1: Using Agent::new_with_config() with explicit API key");
    println!("{}", "=".repeat(60));

    match std::env::var("GROQ_API_KEY") {
        Ok(api_key) => {
            println!("✓ GROQ_API_KEY found in environment\n");

            let groq_config = LLMConfig::new("groq::llama-3.3-70b-versatile")
                .with_api_key(api_key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            match Agent::new_with_config("Groq Agent", groq_config) {
                Ok(mut agent) => {
                    println!("✓ Groq agent created successfully!\n");

                    println!("Running task: 'What is 2 + 2?'");
                    let task = TaskRequest::new("What is 2 + 2? Answer in one short sentence.");
                    println!("Sending request to Groq API...\n");

                    let response = agent.run(task).await;

                    println!("Response received:");
                    println!("================");
                    println!("{:?}", response.result());
                    println!("================\n");

                    println!("🎉 Test 1 completed successfully!");
                }
                Err(e) => {
                    println!("✗ Failed to create Groq agent: {}\n", e);
                }
            }
        }
        Err(_) => {
            println!("✗ GROQ_API_KEY not found in environment");
            println!("  Please set GROQ_API_KEY to run this test\n");
        }
    }

    // Test 2: Using Agent::new() with environment variable - Simpler approach
    println!("\n{}", "=".repeat(60));
    println!("Test 2: Using Agent::new() with environment variable");
    println!("{}", "=".repeat(60));

    if std::env::var("GROQ_API_KEY").is_ok() {
        println!("✓ GROQ_API_KEY is set, agent will use it automatically\n");

        match std::panic::catch_unwind(|| {
            Agent::new("Simple Groq Agent", "groq::llama-3.3-70b-versatile")
        }) {
            Ok(mut agent) => {
                println!("✓ Groq agent created successfully with auto API key!\n");

                println!("Running task: 'What is the capital of France?'");
                let task = TaskRequest::new("What is the capital of France? Answer in one word.");

                let response = agent.run(task).await;

                println!("Response received:");
                println!("================");
                println!("{:?}", response.result());
                println!("================\n");

                println!("🎉 Test 2 completed successfully!");
            }
            Err(_) => {
                println!("✗ Failed to create agent (unexpected panic)\n");
            }
        }
    } else {
        println!("✗ GROQ_API_KEY not set, skipping this test\n");
    }

    println!("\n{}", "=".repeat(60));
    println!("All tests completed!");
    println!("{}", "=".repeat(60));

    Ok(())
}

pub fn with_api_key(self, api_key: impl Into<String>) -> Self

Set API key

Examples found in repository

examples/08_llm_providers.rs (line 174)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

/// Example 3: Provider-specific features
async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

/// Example 4: Compare providers
async fn compare_providers() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Comparing responses across providers:\n");

    let providers = vec![
        ("OpenAI GPT-4", "openai::gpt-4", std::env::var("OPENAI_API_KEY").ok()),
        ("Anthropic Claude", "anthropic::claude-3-sonnet-20240229", std::env::var("ANTHROPIC_API_KEY").ok()),
        ("Ollama Llama", "ollama::llama3.2", None),
        ("Google Gemini", "google::gemini-pro", std::env::var("GOOGLE_API_KEY").ok()),
        ("Groq Mixtral", "groq::mixtral-8x7b-32768", std::env::var("GROQ_API_KEY").ok()),
    ];

    for (name, model, api_key) in providers {
        println!("🤖 {}:", name);

        let mut agent = Agent::new(name, model);

        // Configure with LLMConfig if API key is available
        if let Some(key) = api_key {
            let config = LLMConfig::new(model)
                .with_api_key(key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            if let Ok(_) = agent.with_llm_config(config) {
                let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
                let response = agent.run(task).await;
                println!("   ✓ {:?}", response.result());
            }
        } else {
            // Try without explicit API key (for Ollama or env vars)
            let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
            let response = agent.run(task).await;
            println!("   ✓ {:?}", response.result());
        }

        println!();
    }

    Ok(())
}

examples/09_test_groq.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing Groq LLM Provider with API Key\n");

    // Test 1: Using Agent::new_with_config() - Recommended approach
    println!("{}", "=".repeat(60));
    println!("Test 1: Using Agent::new_with_config() with explicit API key");
    println!("{}", "=".repeat(60));

    match std::env::var("GROQ_API_KEY") {
        Ok(api_key) => {
            println!("✓ GROQ_API_KEY found in environment\n");

            let groq_config = LLMConfig::new("groq::llama-3.3-70b-versatile")
                .with_api_key(api_key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            match Agent::new_with_config("Groq Agent", groq_config) {
                Ok(mut agent) => {
                    println!("✓ Groq agent created successfully!\n");

                    println!("Running task: 'What is 2 + 2?'");
                    let task = TaskRequest::new("What is 2 + 2? Answer in one short sentence.");
                    println!("Sending request to Groq API...\n");

                    let response = agent.run(task).await;

                    println!("Response received:");
                    println!("================");
                    println!("{:?}", response.result());
                    println!("================\n");

                    println!("🎉 Test 1 completed successfully!");
                }
                Err(e) => {
                    println!("✗ Failed to create Groq agent: {}\n", e);
                }
            }
        }
        Err(_) => {
            println!("✗ GROQ_API_KEY not found in environment");
            println!("  Please set GROQ_API_KEY to run this test\n");
        }
    }

    // Test 2: Using Agent::new() with environment variable - Simpler approach
    println!("\n{}", "=".repeat(60));
    println!("Test 2: Using Agent::new() with environment variable");
    println!("{}", "=".repeat(60));

    if std::env::var("GROQ_API_KEY").is_ok() {
        println!("✓ GROQ_API_KEY is set, agent will use it automatically\n");

        match std::panic::catch_unwind(|| {
            Agent::new("Simple Groq Agent", "groq::llama-3.3-70b-versatile")
        }) {
            Ok(mut agent) => {
                println!("✓ Groq agent created successfully with auto API key!\n");

                println!("Running task: 'What is the capital of France?'");
                let task = TaskRequest::new("What is the capital of France? Answer in one word.");

                let response = agent.run(task).await;

                println!("Response received:");
                println!("================");
                println!("{:?}", response.result());
                println!("================\n");

                println!("🎉 Test 2 completed successfully!");
            }
            Err(_) => {
                println!("✗ Failed to create agent (unexpected panic)\n");
            }
        }
    } else {
        println!("✗ GROQ_API_KEY not set, skipping this test\n");
    }

    println!("\n{}", "=".repeat(60));
    println!("All tests completed!");
    println!("{}", "=".repeat(60));

    Ok(())
}

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

Set base URL

Examples found in repository

examples/08_llm_providers.rs (line 248)

async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

pub fn with_max_tokens(self, max_tokens: u32) -> Self

Set max tokens

Examples found in repository

examples/08_llm_providers.rs (line 176)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

/// Example 3: Provider-specific features
async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

/// Example 4: Compare providers
async fn compare_providers() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Comparing responses across providers:\n");

    let providers = vec![
        ("OpenAI GPT-4", "openai::gpt-4", std::env::var("OPENAI_API_KEY").ok()),
        ("Anthropic Claude", "anthropic::claude-3-sonnet-20240229", std::env::var("ANTHROPIC_API_KEY").ok()),
        ("Ollama Llama", "ollama::llama3.2", None),
        ("Google Gemini", "google::gemini-pro", std::env::var("GOOGLE_API_KEY").ok()),
        ("Groq Mixtral", "groq::mixtral-8x7b-32768", std::env::var("GROQ_API_KEY").ok()),
    ];

    for (name, model, api_key) in providers {
        println!("🤖 {}:", name);

        let mut agent = Agent::new(name, model);

        // Configure with LLMConfig if API key is available
        if let Some(key) = api_key {
            let config = LLMConfig::new(model)
                .with_api_key(key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            if let Ok(_) = agent.with_llm_config(config) {
                let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
                let response = agent.run(task).await;
                println!("   ✓ {:?}", response.result());
            }
        } else {
            // Try without explicit API key (for Ollama or env vars)
            let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
            let response = agent.run(task).await;
            println!("   ✓ {:?}", response.result());
        }

        println!();
    }

    Ok(())
}

examples/09_test_groq.rs (line 21)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing Groq LLM Provider with API Key\n");

    // Test 1: Using Agent::new_with_config() - Recommended approach
    println!("{}", "=".repeat(60));
    println!("Test 1: Using Agent::new_with_config() with explicit API key");
    println!("{}", "=".repeat(60));

    match std::env::var("GROQ_API_KEY") {
        Ok(api_key) => {
            println!("✓ GROQ_API_KEY found in environment\n");

            let groq_config = LLMConfig::new("groq::llama-3.3-70b-versatile")
                .with_api_key(api_key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            match Agent::new_with_config("Groq Agent", groq_config) {
                Ok(mut agent) => {
                    println!("✓ Groq agent created successfully!\n");

                    println!("Running task: 'What is 2 + 2?'");
                    let task = TaskRequest::new("What is 2 + 2? Answer in one short sentence.");
                    println!("Sending request to Groq API...\n");

                    let response = agent.run(task).await;

                    println!("Response received:");
                    println!("================");
                    println!("{:?}", response.result());
                    println!("================\n");

                    println!("🎉 Test 1 completed successfully!");
                }
                Err(e) => {
                    println!("✗ Failed to create Groq agent: {}\n", e);
                }
            }
        }
        Err(_) => {
            println!("✗ GROQ_API_KEY not found in environment");
            println!("  Please set GROQ_API_KEY to run this test\n");
        }
    }

    // Test 2: Using Agent::new() with environment variable - Simpler approach
    println!("\n{}", "=".repeat(60));
    println!("Test 2: Using Agent::new() with environment variable");
    println!("{}", "=".repeat(60));

    if std::env::var("GROQ_API_KEY").is_ok() {
        println!("✓ GROQ_API_KEY is set, agent will use it automatically\n");

        match std::panic::catch_unwind(|| {
            Agent::new("Simple Groq Agent", "groq::llama-3.3-70b-versatile")
        }) {
            Ok(mut agent) => {
                println!("✓ Groq agent created successfully with auto API key!\n");

                println!("Running task: 'What is the capital of France?'");
                let task = TaskRequest::new("What is the capital of France? Answer in one word.");

                let response = agent.run(task).await;

                println!("Response received:");
                println!("================");
                println!("{:?}", response.result());
                println!("================\n");

                println!("🎉 Test 2 completed successfully!");
            }
            Err(_) => {
                println!("✗ Failed to create agent (unexpected panic)\n");
            }
        }
    } else {
        println!("✗ GROQ_API_KEY not set, skipping this test\n");
    }

    println!("\n{}", "=".repeat(60));
    println!("All tests completed!");
    println!("{}", "=".repeat(60));

    Ok(())
}

pub fn with_temperature(self, temperature: f32) -> Self

Set temperature

Examples found in repository

examples/08_llm_providers.rs (line 175)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

/// Example 3: Provider-specific features
async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

/// Example 4: Compare providers
async fn compare_providers() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Comparing responses across providers:\n");

    let providers = vec![
        ("OpenAI GPT-4", "openai::gpt-4", std::env::var("OPENAI_API_KEY").ok()),
        ("Anthropic Claude", "anthropic::claude-3-sonnet-20240229", std::env::var("ANTHROPIC_API_KEY").ok()),
        ("Ollama Llama", "ollama::llama3.2", None),
        ("Google Gemini", "google::gemini-pro", std::env::var("GOOGLE_API_KEY").ok()),
        ("Groq Mixtral", "groq::mixtral-8x7b-32768", std::env::var("GROQ_API_KEY").ok()),
    ];

    for (name, model, api_key) in providers {
        println!("🤖 {}:", name);

        let mut agent = Agent::new(name, model);

        // Configure with LLMConfig if API key is available
        if let Some(key) = api_key {
            let config = LLMConfig::new(model)
                .with_api_key(key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            if let Ok(_) = agent.with_llm_config(config) {
                let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
                let response = agent.run(task).await;
                println!("   ✓ {:?}", response.result());
            }
        } else {
            // Try without explicit API key (for Ollama or env vars)
            let task = TaskRequest::new("Explain the concept of 'ownership' in Rust in one sentence.");
            let response = agent.run(task).await;
            println!("   ✓ {:?}", response.result());
        }

        println!();
    }

    Ok(())
}

examples/09_test_groq.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing Groq LLM Provider with API Key\n");

    // Test 1: Using Agent::new_with_config() - Recommended approach
    println!("{}", "=".repeat(60));
    println!("Test 1: Using Agent::new_with_config() with explicit API key");
    println!("{}", "=".repeat(60));

    match std::env::var("GROQ_API_KEY") {
        Ok(api_key) => {
            println!("✓ GROQ_API_KEY found in environment\n");

            let groq_config = LLMConfig::new("groq::llama-3.3-70b-versatile")
                .with_api_key(api_key)
                .with_temperature(0.7)
                .with_max_tokens(100);

            match Agent::new_with_config("Groq Agent", groq_config) {
                Ok(mut agent) => {
                    println!("✓ Groq agent created successfully!\n");

                    println!("Running task: 'What is 2 + 2?'");
                    let task = TaskRequest::new("What is 2 + 2? Answer in one short sentence.");
                    println!("Sending request to Groq API...\n");

                    let response = agent.run(task).await;

                    println!("Response received:");
                    println!("================");
                    println!("{:?}", response.result());
                    println!("================\n");

                    println!("🎉 Test 1 completed successfully!");
                }
                Err(e) => {
                    println!("✗ Failed to create Groq agent: {}\n", e);
                }
            }
        }
        Err(_) => {
            println!("✗ GROQ_API_KEY not found in environment");
            println!("  Please set GROQ_API_KEY to run this test\n");
        }
    }

    // Test 2: Using Agent::new() with environment variable - Simpler approach
    println!("\n{}", "=".repeat(60));
    println!("Test 2: Using Agent::new() with environment variable");
    println!("{}", "=".repeat(60));

    if std::env::var("GROQ_API_KEY").is_ok() {
        println!("✓ GROQ_API_KEY is set, agent will use it automatically\n");

        match std::panic::catch_unwind(|| {
            Agent::new("Simple Groq Agent", "groq::llama-3.3-70b-versatile")
        }) {
            Ok(mut agent) => {
                println!("✓ Groq agent created successfully with auto API key!\n");

                println!("Running task: 'What is the capital of France?'");
                let task = TaskRequest::new("What is the capital of France? Answer in one word.");

                let response = agent.run(task).await;

                println!("Response received:");
                println!("================");
                println!("{:?}", response.result());
                println!("================\n");

                println!("🎉 Test 2 completed successfully!");
            }
            Err(_) => {
                println!("✗ Failed to create agent (unexpected panic)\n");
            }
        }
    } else {
        println!("✗ GROQ_API_KEY not set, skipping this test\n");
    }

    println!("\n{}", "=".repeat(60));
    println!("All tests completed!");
    println!("{}", "=".repeat(60));

    Ok(())
}

pub fn with_top_p(self, top_p: f32) -> Self

Set top_p

Examples found in repository

examples/08_llm_providers.rs (line 177)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

pub fn with_top_k(self, top_k: u32) -> Self

Set top_k

pub fn with_system(self, system: impl Into<String>) -> Self

Set system prompt

Examples found in repository

examples/08_llm_providers.rs (line 223)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

pub fn with_timeout_seconds(self, timeout: u64) -> Self

Set timeout in seconds

pub fn with_reasoning(self, enabled: bool) -> Self

Enable reasoning (for supported providers)

Examples found in repository

examples/08_llm_providers.rs (line 210)

async fn advanced_configuration() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Using LLMConfig for advanced configuration:\n");

    // Method 1: Using Agent::new_with_config() (Recommended for explicit API keys)
    println!("📘 Using Agent::new_with_config() with explicit API key:");
    if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
        let config = LLMConfig::new("openai::gpt-4")
            .with_api_key(api_key)
            .with_temperature(0.7)
            .with_max_tokens(150)
            .with_top_p(0.9);

        if let Ok(mut agent) = Agent::new_with_config("Configured Assistant", config) {
            let task1 = TaskRequest::new("Explain quantum computing in one sentence.");
            let response = agent.run(task1).await;
            println!("   Response: {:?}\n", response.result());
        }
    } else {
        println!("   Skipped (OPENAI_API_KEY not set)\n");
    }

    // Method 2: Using Agent::new() then with_llm_config() (Alternative approach)
    println!("📗 Using Agent::new() then with_llm_config():");
    let mut agent = Agent::new("Configured Assistant", "openai::gpt-4");

    let config = LLMConfig::new("openai::gpt-4")
        .with_temperature(0.8)
        .with_max_tokens(200);

    if let Ok(_) = agent.with_llm_config(config) {
        let task2 = TaskRequest::new("What is machine learning in one sentence?");
        let response = agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Anthropic with reasoning
    println!("📗 Anthropic with extended thinking:");
    let mut claude_agent = Agent::new("Thinking Claude", "anthropic::claude-3-opus-20240229");

    let claude_config = LLMConfig::new("anthropic::claude-3-opus-20240229")
        .with_api_key(std::env::var("ANTHROPIC_API_KEY").unwrap_or_default())
        .with_temperature(0.5)
        .with_max_tokens(200)
        .with_reasoning(true);

    if let Ok(_) = claude_agent.with_llm_config(claude_config) {
        let task2 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = claude_agent.run(task2).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Ollama with custom system prompt
    println!("📙 Ollama with custom system prompt:");
    let mut ollama_agent = Agent::new("Custom Ollama", "ollama::llama3.2");

    let ollama_config = LLMConfig::new("ollama::llama3.2")
        .with_system("You are a concise and technical AI assistant.")
        .with_max_tokens(100)
        .with_temperature(0.3);

    if let Ok(_) = ollama_agent.with_llm_config(ollama_config) {
        let task3 = TaskRequest::new("Explain quantum computing in one sentence.");
        let response = ollama_agent.run(task3).await;
        println!("   Response: {:?}\n", response.result());
    }

    Ok(())
}

pub fn with_reasoning_effort(self, effort: impl Into<String>) -> Self

Set reasoning effort

pub fn with_deployment_id(self, deployment_id: impl Into<String>) -> Self

Set Azure deployment ID

Examples found in repository

examples/08_llm_providers.rs (line 246)

async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

pub fn with_api_version(self, api_version: impl Into<String>) -> Self

Set Azure API version

Examples found in repository

examples/08_llm_providers.rs (line 247)

async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

pub fn with_openai_web_search(self, enabled: bool) -> Self

Enable OpenAI web search

Examples found in repository

examples/08_llm_providers.rs (line 260)

async fn provider_specific_features() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n✨ Provider-specific features:\n");

    // Azure OpenAI
    println!("☁️  Azure OpenAI with deployment configuration:");
    let mut azure_agent = Agent::new("Azure Assistant", "azure::gpt-4");

    let azure_config = LLMConfig::new("azure::gpt-4")
        .with_api_key(std::env::var("AZURE_OPENAI_API_KEY").unwrap_or_default())
        .with_deployment_id("your-deployment-id")
        .with_api_version("2024-02-01")
        .with_base_url("https://your-resource.openai.azure.com");

    if let Ok(_) = azure_agent.with_llm_config(azure_config) {
        println!("   ✓ Azure agent configured with deployment settings");
    }

    // OpenAI with web search
    println!("\n🌐 OpenAI with web search enabled:");
    let mut search_agent = Agent::new("Search Assistant", "openai::gpt-4");

    let search_config = LLMConfig::new("openai::gpt-4")
        .with_api_key(std::env::var("OPENAI_API_KEY").unwrap_or_default())
        .with_openai_web_search(true);

    if let Ok(_) = search_agent.with_llm_config(search_config) {
        let task1 = TaskRequest::new("What are the latest developments in AI?");
        let response = search_agent.run(task1).await;
        println!("   Response (with web search): {:?}\n", response.result());
    }

    // DeepSeek
    println!("🔍 DeepSeek for code-focused tasks:");
    let mut deepseek_agent = Agent::new("DeepSeek Assistant", "deepseek::deepseek-coder");

    let deepseek_config = LLMConfig::new("deepseek::deepseek-coder")
        .with_api_key(std::env::var("DEEPSEEK_API_KEY").unwrap_or_default())
        .with_temperature(0.2);

    if let Ok(_) = deepseek_agent.with_llm_config(deepseek_config) {
        let code_task = TaskRequest::new("Write a Rust function to calculate fibonacci numbers");
        let response = deepseek_agent.run(code_task).await;
        println!("   Response: {:?}\n", response.result());
    }

    // Mistral
    println!("🌟 Mistral for European AI:");
    let mut mistral_agent = Agent::new("Mistral Assistant", "mistral::mistral-large-latest");

    let mistral_config = LLMConfig::new("mistral::mistral-large-latest")
        .with_api_key(std::env::var("MISTRAL_API_KEY").unwrap_or_default())
        .with_temperature(0.7)
        .with_max_tokens(500);

    if let Ok(_) = mistral_agent.with_llm_config(mistral_config) {
        println!("   ✓ Mistral agent configured");
    }

    Ok(())
}

pub fn with_resilience(self, enabled: bool, attempts: usize) -> Self

Enable resilience with retry/backoff

Trait Implementations

impl Clone for LLMConfig

fn clone(&self) -> LLMConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LLMConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LLMConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LLMConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LLMConfig> for LLMProviderConfig

fn from(config: LLMConfig) -> Self

Converts to this type from the input type.

impl Serialize for LLMConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.