Struct LMBuilder 

pub struct LMBuilder<S: State = Empty> { /* private fields */ }

Use builder syntax to set the inputs and finish with __internal_build().

Implementations

impl<S: State> LMBuilder<S>

pub fn base_url(self, value: String) -> LMBuilder<SetBaseUrl<S>>

where S::BaseUrl: IsUnset,

Optional (Some / Option setters).

pub fn maybe_base_url(self, value: Option<String>) -> LMBuilder<SetBaseUrl<S>>

where S::BaseUrl: IsUnset,

Optional (Some / Option setters).

pub fn api_key(self, value: String) -> LMBuilder<SetApiKey<S>>

where S::ApiKey: IsUnset,

Optional (Some / Option setters).

pub fn maybe_api_key(self, value: Option<String>) -> LMBuilder<SetApiKey<S>>

where S::ApiKey: IsUnset,

Optional (Some / Option setters).

pub fn model(self, value: String) -> LMBuilder<SetModel<S>>

where S::Model: IsUnset,

Optional (Some / Option setters). Default: "openai:gpt-4o-mini".to_string().

Examples found in repository

examples/01-simple.rs (line 74)

async fn main() -> Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter,
    );

    let example = example! {
        "question": "input" => "What is the capital of France?",
    };

    let qa_rater = QARater::builder().build();
    let prediction = qa_rater.forward(example).await.unwrap();
    println!("{prediction:?}");

    Ok(())
}

examples/05-heterogenous-examples.rs (line 16)

async fn main() -> anyhow::Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter {},
    );

    let exp = example! {
        "number": "input" => 10,
    };
    let predict = Predict::new(sign! {
        (number: i32) -> number_squared: i32, number_cubed: i32
    });

    let prediction = predict.forward(exp).await?;
    println!("{prediction:?}");

    Ok(())
}

examples/07-inspect-history.rs (line 32)

async fn main() {
    let lm = LM::builder()
        .model("openai:gpt-4o-mini".to_string())
        .build()
        .await
        .unwrap();
    configure(lm, ChatAdapter);

    let example = example! {
        "question": "input" => "What is the capital of France?",
    };

    let qa_rater = QARater::builder().build();
    let prediction = qa_rater.forward(example.clone()).await.unwrap();
    println!("Prediction: {prediction:?}");

    let history = get_lm().inspect_history(1).await;
    println!("History: {history:?}");
}

examples/03-evaluate-hotpotqa.rs (line 67)

async fn main() -> anyhow::Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await?,
        ChatAdapter {},
    );

    let examples = DataLoader::load_hf(
        "hotpotqa/hotpot_qa",
        vec!["question".to_string()],
        vec!["answer".to_string()],
        "fullwiki",
        "validation",
        true,
    )?[..128]
        .to_vec();

    let evaluator = QARater::builder().build();
    let metric = evaluator.evaluate(examples).await;

    println!("Metric: {metric}");
    Ok(())
}

examples/04-optimize-hotpotqa.rs (line 63)

async fn main() -> anyhow::Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter {},
    );

    let examples = DataLoader::load_hf(
        "hotpotqa/hotpot_qa",
        vec!["question".to_string()],
        vec!["answer".to_string()],
        "fullwiki",
        "validation",
        true,
    )?[..10]
        .to_vec();

    let mut rater = QARater::builder().build();
    let optimizer = COPRO::builder().breadth(10).depth(1).build();

    println!("Rater: {:?}", rater.answerer.get_signature().instruction());

    optimizer.compile(&mut rater, examples.clone()).await?;

    println!("Rater: {:?}", rater.answerer.get_signature().instruction());

    Ok(())
}

examples/06-other-providers-batch.rs (line 81)

async fn main() {
    // Anthropic
    configure(
        LM::builder()
            .model("anthropic:claude-sonnet-4-5-20250929".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter,
    );

    let example = vec![
        example! {
            "question": "input" => "What is the capital of France?",
        },
        example! {
            "question": "input" => "What is the capital of Germany?",
        },
        example! {
            "question": "input" => "What is the capital of Italy?",
        },
    ];

    let qa_rater = QARater::builder().build();
    let prediction = qa_rater.batch(example.clone(), 2, true).await.unwrap();
    println!("Anthropic: {prediction:?}");

    // Gemini
    configure(
        LM::builder()
            .model("gemini:gemini-2.0-flash".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter,
    );

    let prediction = qa_rater.batch(example, 2, true).await.unwrap();
    println!("Gemini: {prediction:?}");
}

pub fn maybe_model(self, value: Option<String>) -> LMBuilder<SetModel<S>>

where S::Model: IsUnset,

Optional (Some / Option setters). Default: "openai:gpt-4o-mini".to_string().

pub fn temperature(self, value: f32) -> LMBuilder<SetTemperature<S>>

where S::Temperature: IsUnset,

Optional (Some / Option setters). Default: 0.7.

Examples found in repository

examples/09-gepa-sentiment.rs (line 120)

async fn main() -> Result<()> {
    println!("GEPA Sentiment Analysis Optimization Example\n");

    // Setup LM
    let lm = LM::builder().temperature(0.7).build().await.unwrap();

    configure(lm.clone(), ChatAdapter);

    // Create training examples with diverse sentiments
    let trainset = vec![
        example! {
            "text": "input" => "This movie was absolutely fantastic! I loved every minute of it.",
            "expected_sentiment": "input" => "positive"
        },
        example! {
            "text": "input" => "Terrible service, will never come back again.",
            "expected_sentiment": "input" => "negative"
        },
        example! {
            "text": "input" => "The weather is okay, nothing special.",
            "expected_sentiment": "input" => "neutral"
        },
        example! {
            "text": "input" => "Despite some minor issues, I'm quite happy with the purchase.",
            "expected_sentiment": "input" => "positive"
        },
        example! {
            "text": "input" => "I have mixed feelings about this product.",
            "expected_sentiment": "input" => "neutral"
        },
        example! {
            "text": "input" => "This is the worst experience I've ever had!",
            "expected_sentiment": "input" => "negative"
        },
        example! {
            "text": "input" => "It's fine. Does what it's supposed to do.",
            "expected_sentiment": "input" => "neutral"
        },
        example! {
            "text": "input" => "Exceeded all my expectations! Highly recommend!",
            "expected_sentiment": "input" => "positive"
        },
        example! {
            "text": "input" => "Disappointed and frustrated with the outcome.",
            "expected_sentiment": "input" => "negative"
        },
        example! {
            "text": "input" => "Standard quality, nothing remarkable.",
            "expected_sentiment": "input" => "neutral"
        },
    ];

    // Create module
    let mut module = SentimentAnalyzer::builder()
        .predictor(Predict::new(SentimentSignature::new()))
        .build();

    // Evaluate baseline performance
    println!("Baseline Performance:");
    let baseline_score = module.evaluate(trainset.clone()).await;
    println!("  Average score: {:.3}\n", baseline_score);

    // Configure GEPA optimizer
    let gepa = GEPA::builder()
        .num_iterations(5)
        .minibatch_size(5)
        .num_trials(3)
        .temperature(0.9)
        .track_stats(true)
        .build();

    // Run optimization
    println!("Starting GEPA optimization...\n");
    let result = gepa
        .compile_with_feedback(&mut module, trainset.clone())
        .await?;

    // Display results
    println!("\nOptimization Results:");
    println!(
        "  Best average score: {:.3}",
        result.best_candidate.average_score()
    );
    println!("  Total rollouts: {}", result.total_rollouts);
    println!("  Total LM calls: {}", result.total_lm_calls);
    println!("  Generations: {}", result.evolution_history.len());

    println!("\nBest Instruction:");
    println!("  {}", result.best_candidate.instruction);

    if !result.evolution_history.is_empty() {
        println!("\nEvolution History:");
        for entry in &result.evolution_history {
            println!("  Generation {}: {:.3}", entry.0, entry.1);
        }
    }

    // Test optimized module on a new example
    println!("\nTesting Optimized Module:");
    let test_example = example! {
        "text": "input" => "This product changed my life! Absolutely amazing!",
        "expected_sentiment": "input" => "positive"
    };

    let test_prediction = module.forward(test_example.clone()).await?;
    let test_feedback = module
        .feedback_metric(&test_example, &test_prediction)
        .await;

    println!(
        "  Test prediction: {}",
        test_prediction.get("sentiment", None)
    );
    println!("  Test score: {:.3}", test_feedback.score);
    println!("  Feedback:\n{}", test_feedback.feedback);

    Ok(())
}

examples/10-gepa-llm-judge.rs (line 226)

async fn main() -> Result<()> {
    println!("GEPA with LLM-as-a-Judge Example\n");
    println!("This example shows how to use an LLM judge to automatically");
    println!("generate rich feedback for optimizing a math solver.\n");

    // Setup: Configure the LLM
    // Main LM for the task
    let task_lm = LM::builder().temperature(0.7).build().await.unwrap();

    // Judge LM (could use a different/cheaper model)
    let judge_lm = LM::builder().temperature(0.3).build().await.unwrap();

    configure(task_lm, ChatAdapter);

    // Create training examples
    let trainset = vec![
        example! {
            "problem": "input" => "Sarah has 12 apples. She gives 3 to her friend and buys 5 more. How many apples does she have now?",
            "expected_answer": "input" => "14"
        },
        example! {
            "problem": "input" => "A train travels 60 miles in 1 hour. How far will it travel in 3.5 hours at the same speed?",
            "expected_answer": "input" => "210"
        },
        example! {
            "problem": "input" => "There are 24 students in a class. If 1/3 of them are absent, how many students are present?",
            "expected_answer": "input" => "16"
        },
        example! {
            "problem": "input" => "A rectangle has length 8 cm and width 5 cm. What is its area?",
            "expected_answer": "input" => "40"
        },
        example! {
            "problem": "input" => "John has $50. He spends $12 on lunch and $8 on a book. How much money does he have left?",
            "expected_answer": "input" => "30"
        },
    ];

    // Create the module
    let mut module = MathSolver::builder()
        .solver(Predict::new(MathWordProblem::new()))
        .judge(Predict::new(MathJudge::new()))
        .judge_lm(Arc::new(judge_lm))
        .build();

    // Evaluate baseline performance
    println!("Step 1: Baseline Performance");
    println!("Testing the solver before optimization...\n");
    let baseline_score = module.evaluate(trainset.clone()).await;
    println!("  Baseline average score: {:.3}\n", baseline_score);

    // Configure GEPA optimizer
    println!("Step 2: Configure GEPA");
    println!("Setting up the optimizer with budget controls...\n");

    let gepa = GEPA::builder()
        .num_iterations(3) // Fewer iterations for demo
        .minibatch_size(3) // Smaller batches
        .temperature(0.9)
        .track_stats(true)
        .maybe_max_lm_calls(Some(100)) // Important: we're using 2x LM calls (task + judge)
        .build();

    // Run GEPA optimization
    println!("Step 3: Run GEPA Optimization");
    println!("The judge will analyze reasoning quality and provide feedback...\n");

    let result = gepa
        .compile_with_feedback(&mut module, trainset.clone())
        .await?;

    // Display results
    println!("\nStep 4: Results");
    println!("===============\n");
    println!("Optimization complete!");
    println!(
        "  Best average score: {:.3}",
        result.best_candidate.average_score()
    );
    println!(
        "  Improvement: {:.3}",
        result.best_candidate.average_score() - baseline_score
    );
    println!("  Total rollouts: {}", result.total_rollouts);
    println!(
        "  Total LM calls: {} (includes judge evaluations)",
        result.total_lm_calls
    );

    println!("\nEvolution over time:");
    for (generation, score) in &result.evolution_history {
        println!("  Generation {}: {:.3}", generation, score);
    }

    println!("\nOptimized instruction:");
    println!("  {}", result.best_candidate.instruction);

    // Test the optimized solver
    println!("\nStep 5: Test Optimized Solver");
    println!("==============================\n");

    let test_problem = example! {
        "problem": "input" => "A store sells pencils for $0.25 each. If you buy 8 pencils, how much will you pay?",
        "expected_answer": "input" => "2"
    };

    let test_prediction = module.forward(test_problem.clone()).await?;
    let test_feedback = module
        .feedback_metric(&test_problem, &test_prediction)
        .await;

    println!(
        "Test problem: A store sells pencils for $0.25 each. If you buy 8 pencils, how much will you pay?"
    );
    println!("\nAnswer: {}", test_prediction.get("answer", None));
    println!("Score: {:.3}\n", test_feedback.score);
    println!("Detailed Feedback from Judge:");
    println!("{}", test_feedback.feedback);

    Ok(())
}

pub fn maybe_temperature( self, value: Option<f32>, ) -> LMBuilder<SetTemperature<S>>

where S::Temperature: IsUnset,

Optional (Some / Option setters). Default: 0.7.

pub fn max_tokens(self, value: u32) -> LMBuilder<SetMaxTokens<S>>

where S::MaxTokens: IsUnset,

Optional (Some / Option setters). Default: 512.

pub fn maybe_max_tokens(self, value: Option<u32>) -> LMBuilder<SetMaxTokens<S>>

where S::MaxTokens: IsUnset,

Optional (Some / Option setters). Default: 512.

pub fn max_tool_iterations( self, value: u32, ) -> LMBuilder<SetMaxToolIterations<S>>

where S::MaxToolIterations: IsUnset,

Optional (Some / Option setters). Default: 10.

pub fn maybe_max_tool_iterations( self, value: Option<u32>, ) -> LMBuilder<SetMaxToolIterations<S>>

where S::MaxToolIterations: IsUnset,

Optional (Some / Option setters). Default: 10.

pub fn cache(self, value: bool) -> LMBuilder<SetCache<S>>

where S::Cache: IsUnset,

Optional (Some / Option setters). Default: false.

pub fn maybe_cache(self, value: Option<bool>) -> LMBuilder<SetCache<S>>

where S::Cache: IsUnset,

Optional (Some / Option setters). Default: false.

pub fn cache_handler( self, value: Arc<Mutex<ResponseCache>>, ) -> LMBuilder<SetCacheHandler<S>>

where S::CacheHandler: IsUnset,

Optional (Some / Option setters).

pub fn maybe_cache_handler( self, value: Option<Arc<Mutex<ResponseCache>>>, ) -> LMBuilder<SetCacheHandler<S>>

where S::CacheHandler: IsUnset,

Optional (Some / Option setters).

impl<S: State> LMBuilder<S>

pub async fn build(self) -> Result<LM>

Builds the LM instance with proper client initialization

Supports 3 build cases:

1. OpenAI-compatible with auth: base_url + api_key provided
2. Local OpenAI-compatible: base_url only (for vLLM, etc.)
3. Provider via model string: model in “provider:model” format

Examples found in repository

examples/01-simple.rs (line 75)

async fn main() -> Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter,
    );

    let example = example! {
        "question": "input" => "What is the capital of France?",
    };

    let qa_rater = QARater::builder().build();
    let prediction = qa_rater.forward(example).await.unwrap();
    println!("{prediction:?}");

    Ok(())
}

examples/05-heterogenous-examples.rs (line 17)

async fn main() -> anyhow::Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter {},
    );

    let exp = example! {
        "number": "input" => 10,
    };
    let predict = Predict::new(sign! {
        (number: i32) -> number_squared: i32, number_cubed: i32
    });

    let prediction = predict.forward(exp).await?;
    println!("{prediction:?}");

    Ok(())
}

examples/07-inspect-history.rs (line 33)

async fn main() {
    let lm = LM::builder()
        .model("openai:gpt-4o-mini".to_string())
        .build()
        .await
        .unwrap();
    configure(lm, ChatAdapter);

    let example = example! {
        "question": "input" => "What is the capital of France?",
    };

    let qa_rater = QARater::builder().build();
    let prediction = qa_rater.forward(example.clone()).await.unwrap();
    println!("Prediction: {prediction:?}");

    let history = get_lm().inspect_history(1).await;
    println!("History: {history:?}");
}

examples/03-evaluate-hotpotqa.rs (line 68)

async fn main() -> anyhow::Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await?,
        ChatAdapter {},
    );

    let examples = DataLoader::load_hf(
        "hotpotqa/hotpot_qa",
        vec!["question".to_string()],
        vec!["answer".to_string()],
        "fullwiki",
        "validation",
        true,
    )?[..128]
        .to_vec();

    let evaluator = QARater::builder().build();
    let metric = evaluator.evaluate(examples).await;

    println!("Metric: {metric}");
    Ok(())
}

examples/04-optimize-hotpotqa.rs (line 64)

async fn main() -> anyhow::Result<()> {
    configure(
        LM::builder()
            .model("openai:gpt-4o-mini".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter {},
    );

    let examples = DataLoader::load_hf(
        "hotpotqa/hotpot_qa",
        vec!["question".to_string()],
        vec!["answer".to_string()],
        "fullwiki",
        "validation",
        true,
    )?[..10]
        .to_vec();

    let mut rater = QARater::builder().build();
    let optimizer = COPRO::builder().breadth(10).depth(1).build();

    println!("Rater: {:?}", rater.answerer.get_signature().instruction());

    optimizer.compile(&mut rater, examples.clone()).await?;

    println!("Rater: {:?}", rater.answerer.get_signature().instruction());

    Ok(())
}

examples/06-other-providers-batch.rs (line 82)

async fn main() {
    // Anthropic
    configure(
        LM::builder()
            .model("anthropic:claude-sonnet-4-5-20250929".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter,
    );

    let example = vec![
        example! {
            "question": "input" => "What is the capital of France?",
        },
        example! {
            "question": "input" => "What is the capital of Germany?",
        },
        example! {
            "question": "input" => "What is the capital of Italy?",
        },
    ];

    let qa_rater = QARater::builder().build();
    let prediction = qa_rater.batch(example.clone(), 2, true).await.unwrap();
    println!("Anthropic: {prediction:?}");

    // Gemini
    configure(
        LM::builder()
            .model("gemini:gemini-2.0-flash".to_string())
            .build()
            .await
            .unwrap(),
        ChatAdapter,
    );

    let prediction = qa_rater.batch(example, 2, true).await.unwrap();
    println!("Gemini: {prediction:?}");
}

Additional examples can be found in:

• examples/11-custom-client.rs
• examples/09-gepa-sentiment.rs
• examples/10-gepa-llm-judge.rs