Struct FeedbackMetric 

pub struct FeedbackMetric {
    pub score: f32,
    pub feedback: String,
    pub metadata: HashMap<String, Value>,
}

Rich evaluation metric with both score and textual feedback

GEPA uses this to understand why a score was assigned, enabling more targeted prompt improvements.

Fields

score: f32

Numerical score (typically 0.0 to 1.0, but can be any range)

feedback: String

Rich textual feedback explaining the score

Examples:

• “✓ Retrieved 3/3 correct documents”
• “✗ Code failed to compile: missing semicolon on line 5”
• “Partially correct: got answer ‘42’ but expected ‘42.0’”

metadata: HashMap<String, Value>

Optional structured metadata for additional context

Can include:

• Intermediate outputs from pipeline stages
• Error messages and stack traces
• Performance metrics (latency, tokens, cost)
• Domain-specific diagnostics

Implementations

impl FeedbackMetric

pub fn new(score: f32, feedback: impl Into<String>) -> Self

Create a new feedback metric

Examples found in repository

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

    async fn feedback_metric(&self, example: &Example, prediction: &Prediction) -> FeedbackMetric {
        let predicted = prediction
            .get("sentiment", None)
            .as_str()
            .unwrap_or("")
            .to_string()
            .to_lowercase();

        let expected = example
            .get("expected_sentiment", None)
            .as_str()
            .unwrap_or("")
            .to_string()
            .to_lowercase();

        let text = example.get("text", None).as_str().unwrap_or("").to_string();

        let reasoning = prediction
            .get("reasoning", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        // Calculate score
        let correct = predicted == expected;
        let score = if correct { 1.0 } else { 0.0 };

        // Create rich feedback
        let mut feedback = if correct {
            format!("Correct classification: \"{}\"\n", expected)
        } else {
            format!(
                "Incorrect classification\n  Expected: \"{}\"\n  Predicted: \"{}\"\n",
                expected, predicted
            )
        };

        // Add context about the input
        feedback.push_str(&format!("  Input text: \"{}\"\n", text));

        // Add reasoning analysis
        if !reasoning.is_empty() {
            feedback.push_str(&format!("  Reasoning: {}\n", reasoning));

            // Check if reasoning mentions key sentiment words
            let has_reasoning_quality = if correct {
                // For correct answers, check if reasoning is substantive
                reasoning.len() > 20
            } else {
                // For incorrect answers, note what went wrong
                false
            };

            if has_reasoning_quality {
                feedback.push_str("  Reasoning appears detailed\n");
            } else if !correct {
                feedback.push_str("  May have misunderstood the text sentiment\n");
            }
        }

        FeedbackMetric::new(score, feedback)
    }

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

    async fn feedback_metric(&self, example: &Example, prediction: &Prediction) -> FeedbackMetric {
        // Extract the problem and answers
        let problem = example
            .get("problem", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        let expected = example
            .get("expected_answer", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        let student_answer = prediction
            .get("answer", None)
            .as_str()
            .unwrap_or("")
            .to_string();

        let student_reasoning = prediction
            .get("reasoning", None)
            .as_str()
            .unwrap_or("No reasoning provided")
            .to_string();

        // Quick check: is the answer exactly correct?
        let answer_matches = student_answer.trim() == expected.trim();

        // Use LLM judge to analyze the reasoning quality
        // This is where the magic happens - the judge provides rich feedback
        let judge_input = example! {
            "problem": "input" => &problem,
            "expected_answer": "input" => &expected,
            "student_answer": "input" => &student_answer,
            "student_reasoning": "input" => &student_reasoning
        };

        let judge_output = match self
            .judge
            .forward_with_config(judge_input, Arc::clone(&self.judge_lm))
            .await
        {
            Ok(output) => output,
            Err(_) => {
                // If judge fails, fall back to simple feedback
                let score = if answer_matches { 1.0 } else { 0.0 };
                let simple_feedback = format!(
                    "Problem: {}\nExpected: {}\nPredicted: {}\nAnswer: {}",
                    problem,
                    expected,
                    student_answer,
                    if answer_matches {
                        "CORRECT"
                    } else {
                        "INCORRECT"
                    }
                );
                return FeedbackMetric::new(score, simple_feedback);
            }
        };

        let judge_evaluation = judge_output
            .get("evaluation", None)
            .as_str()
            .unwrap_or("Unable to evaluate")
            .to_string();

        // Calculate score based on answer correctness and reasoning quality
        // The judge's evaluation helps us assign partial credit
        let score = if answer_matches {
            // Correct answer - check if reasoning is also sound
            if judge_evaluation.to_lowercase().contains("sound reasoning")
                || judge_evaluation.to_lowercase().contains("correct approach")
            {
                1.0 // Perfect: right answer, good reasoning
            } else {
                0.7 // Right answer but flawed reasoning (lucky guess?)
            }
        } else {
            // Wrong answer - check if there's any partial credit
            if judge_evaluation.to_lowercase().contains("correct approach")
                || judge_evaluation.to_lowercase().contains("good start")
            {
                0.3 // Wrong answer but some valid steps
            } else {
                0.0 // Completely wrong
            }
        };

        // Construct rich textual feedback
        // This combines factual info with the judge's analysis
        let mut feedback = String::new();

        feedback.push_str(&format!("Problem: {}\n", problem));
        feedback.push_str(&format!("Expected: {}\n", expected));
        feedback.push_str(&format!("Predicted: {}\n", student_answer));

        if answer_matches {
            feedback.push_str("Answer: CORRECT\n\n");
        } else {
            feedback.push_str("Answer: INCORRECT\n\n");
        }

        feedback.push_str("Reasoning Quality Analysis:\n");
        feedback.push_str(&judge_evaluation);

        // Return the feedback metric with score and rich text
        FeedbackMetric::new(score, feedback)
    }

pub fn with_metadata( score: f32, feedback: impl Into<String>, metadata: HashMap<String, Value>, ) -> Self

Create a feedback metric with metadata

pub fn add_metadata(self, key: impl Into<String>, value: Value) -> Self

Add metadata to an existing feedback metric

Trait Implementations

impl Clone for FeedbackMetric

fn clone(&self) -> FeedbackMetric

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FeedbackMetric

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

Formats the value using the given formatter.

impl Default for FeedbackMetric

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FeedbackMetric

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FeedbackMetric

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

where __S: Serializer,

Serialize this value into the given Serde serializer.