Struct MonitoringAgent 

pub struct MonitoringAgent;

Implementations

impl MonitoringAgent

pub fn new() -> Self

Examples found in repository

examples/training_flow.rs (line 36)

fn main() -> Result<()> {
    println!("Initializing Converge Analytics training flow...");

    // 1. Initialize Context
    let mut ctx = Context::new();
    ctx.add_fact(Fact::new(
        ContextKey::Seeds,
        "job-1",
        "Train a baseline model on California Housing",
    ))?;

    // 2. Initialize Agents
    let data_dir = PathBuf::from("data");
    let model_dir = PathBuf::from("models");

    let dataset_agent = DatasetAgent::new(data_dir);
    let validator = DataValidationAgent::new();
    let featurizer = FeatureEngineeringAgent::new();
    let hyperparam = HyperparameterSearchAgent::new(12);
    let trainer = ModelTrainingAgent::new(model_dir);
    let evaluator = ModelEvaluationAgent::new();
    let registry = ModelRegistryAgent::new();
    let monitor = MonitoringAgent::new();
    let inference = SampleInferenceAgent::new(5);
    let deployment = DeploymentAgent::new();

    let agents: Vec<Box<dyn Agent>> = vec![
        Box::new(dataset_agent),
        Box::new(validator),
        Box::new(featurizer),
        Box::new(hyperparam),
        Box::new(trainer),
        Box::new(evaluator),
        Box::new(registry),
        Box::new(monitor),
        Box::new(inference),
        Box::new(deployment),
    ];

    // 3. Run Loop (Convergence with quality gate)
    println!("Starting execution loop...");
    let mut iteration = 1usize;
    let mut max_rows = 500usize;
    let quality_threshold = 0.75;
    let max_iterations = 5;
    let mut last_iteration = iteration;

    while iteration <= max_iterations {
        let plan = TrainingPlan {
            iteration,
            max_rows,
            train_fraction: 0.8,
            val_fraction: 0.15,
            infer_fraction: 0.05,
            quality_threshold,
        };
        let plan_content = serde_json::to_string(&plan)?;
        ctx.add_fact(Fact::new(
            ContextKey::Constraints,
            format!("training-plan-{}", iteration),
            plan_content,
        ))?;

        println!(
            "\n--- Iteration {} (max_rows={}) ---",
            iteration, max_rows
        );

        for cycle in 1..=8 {
            println!("Cycle {}", cycle);
            let mut changes = 0;

            for agent in &agents {
                if agent.accepts(&ctx) {
                    println!("Agent {} is active", agent.name());
                    let effect = agent.execute(&ctx);

                    if !effect.is_empty() {
                        for fact in effect.facts {
                            if ctx.add_fact(fact).unwrap_or(false) {
                                changes += 1;
                            }
                        }
                    }
                }
            }

            if changes == 0 {
                break;
            }
        }

        let report = match latest_evaluation_for_iteration(&ctx, iteration) {
            Some(report) => report,
            None => {
                println!("No evaluation report for iteration {}", iteration);
                break;
            }
        };

        println!(
            "Validation MAE: {:.4} | success_ratio: {:.3} | val_rows: {}",
            report.value, report.success_ratio, report.val_rows
        );

        if report.success_ratio >= quality_threshold {
            println!("Quality threshold met. Converged.");
            last_iteration = iteration;
            break;
        }

        let total_rows = latest_total_rows(&ctx).unwrap_or(max_rows);
        if max_rows >= total_rows {
            println!("No more data available to improve quality.");
            break;
        }

        max_rows = (max_rows * 2).min(total_rows);
        println!("Quality below threshold, expanding training rows to {}", max_rows);
        last_iteration = iteration;
        iteration += 1;
    }

    if let Some(eval) = latest_evaluation_for_iteration(&ctx, last_iteration) {
        println!("\nFinal evaluation: {:?}", eval);
    }

    if let Some(hypo) = ctx.get(ContextKey::Hypotheses).last() {
        println!("\nInference sample: {}", hypo.content);
    }

    Ok(())
}

Trait Implementations

impl Agent for MonitoringAgent

fn name(&self) -> &str

Human-readable name for debugging and tracing.

fn dependencies(&self) -> &[ContextKey]

Context keys this agent depends on.

fn accepts(&self, ctx: &Context) -> bool

Returns true if this agent should execute given the current context.

fn execute(&self, ctx: &Context) -> AgentEffect

Execute the agent’s logic and return effects.