LLM-based Agents

use converge_provider::{Provider, Model, Tool, Schema};
use serde::{Deserialize, Serialize};

// Define structured output schema
#[derive(Debug, Serialize, Deserialize, Schema)]
struct AnalysisResult {
    sentiment: Sentiment,
    confidence: f32,
    key_points: Vec<String>,
    suggested_actions: Vec<Action>,
}

#[derive(Debug, Serialize, Deserialize, Schema)]
enum Sentiment { Positive, Negative, Neutral, Mixed }

#[derive(Debug, Serialize, Deserialize, Schema)]
struct Action {
    description: String,
    priority: u8,
}

// Define tools the agent can use
fn search_tool() -> Tool {
    Tool::new("search")
        .description("Search the knowledge base")
        .param("query", "string", "Search query")
        .param("limit", "integer", "Max results (default 10)")
}

async fn analyze_document(provider: &Provider, document: &str) -> Result<AnalysisResult> {
    // Provider handles model selection, retries, structured output
    let result = provider
        .completion()
        .model(Model::ClaudeSonnet)
        .fallback(Model::Gpt4o)
        .system("You are a document analyst. Analyze the provided document.")
        .user(document)
        .tools([search_tool()])
        .structured_output::<AnalysisResult>()
        .send()
        .await?;

    Ok(result)
}

// Streaming with structured output
async fn stream_analysis(provider: &Provider, document: &str) -> Result<()> {
    let mut stream = provider
        .completion()
        .model(Model::ClaudeSonnet)
        .user(document)
        .structured_output::<AnalysisResult>()
        .stream()
        .await?;

    while let Some(chunk) = stream.next().await {
        match chunk? {
            StreamChunk::Partial(json) => println!("Progress: {}", json),
            StreamChunk::ToolCall(call) => println!("Tool: {} ({})", call.name, call.id),
            StreamChunk::Complete(result) => return Ok(result),
        }
    }
    Err(Error::StreamEnded)
}

Converge-Provider abstracts model differences. Structured outputs are schema-enforced. Fallbacks handle provider outages. Streaming works with tools and structured output.

use converge_provider::{Provider, Model, Router};

// Route to different models based on task
fn create_router() -> Router {
    Router::new()
        // Fast/cheap for classification
        .route("classify", Model::Gpt4oMini)
        .route("extract_entities", Model::Gpt4oMini)

        // Frontier for reasoning
        .route("analyze", Model::ClaudeSonnet)
        .route("plan", Model::ClaudeOpus)

        // Long context for documents
        .route("summarize_long", Model::Gemini2Pro)

        // Local for privacy
        .route("process_pii", Model::Llama3_70b_Local)

        // Default
        .default(Model::ClaudeSonnet)
}

async fn process_request(provider: &Provider, task: &str, input: &str) -> Result<String> {
    let router = create_router();
    let model = router.select(task);

    provider
        .completion()
        .model(model)
        .user(input)
        .send()
        .await
}

// Parallel model comparison for evaluation
async fn compare_models(provider: &Provider, prompt: &str) -> Result<Comparison> {
    let models = [Model::ClaudeSonnet, Model::Gpt4o, Model::Gemini2Pro];

    let results = futures::future::join_all(
        models.iter().map(|model| {
            provider.completion().model(*model).user(prompt).send()
        })
    ).await;

    Ok(Comparison::new(models.iter().zip(results).collect()))
}

Router directs tasks to appropriate models. Parallel execution enables A/B testing and model comparison. Privacy-sensitive data routes to local models automatically.