Struct InferenceAgent 

pub struct InferenceAgent {}

Implementations

impl InferenceAgent

pub fn new() -> Self

Examples found in repository

examples/agent_loop.rs (line 55)

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

    // 0. Setup Dataset
    let data_path = Path::new("california_housing_train.parquet");
    // Ensure we can write to CWD or use a temp dir.
    // In most CI/dev envs, CWD is writable.
    download_dataset_if_missing(data_path)?;

    // 1. Initialize Context
    let mut ctx = Context::new();

    // Seed with intent to analyze
    ctx.add_fact(Fact::new(
        ContextKey::Seeds,
        "job-1",
        "Analyze housing data",
    ))?;

    // 2. Initialize Agents
    let feature_agent = FeatureAgent::new(Some(data_path.to_path_buf()));
    let inference_agent = InferenceAgent::new();

    let agents: Vec<Box<dyn Agent>> = vec![Box::new(feature_agent), Box::new(inference_agent)];

    // 3. Run Loop (Simplified Engine)
    // Real engine runs until convergence. Here we run fixed steps for demo.
    println!("Starting execution loop...");
    for cycle in 1..=3 {
        println!("\n--- 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() {
                    println!(
                        "Agent {} produced {} facts, {} proposals",
                        agent.name(),
                        effect.facts.len(),
                        effect.proposals.len()
                    );

                    // Emulate engine merging
                    for fact in effect.facts {
                        if ctx.add_fact(fact).unwrap_or(false) {
                            changes += 1;
                        }
                    }

                    // Emulate proposal validation (auto-promote for demo)
                    for proposal in effect.proposals {
                        // In real engine: validation logic.
                        // Here: naive promotion.
                        if let Ok(fact) = Fact::try_from(proposal) {
                            if ctx.add_fact(fact).unwrap_or(false) {
                                changes += 1;
                            }
                        }
                    }
                }
            } else {
                println!("Agent {} skipped", agent.name());
            }
        }

        // Print state
        for key in ctx.all_keys() {
            let count = ctx.get(key).len();
            println!("Context[{:?}] = {} facts", key, count);
        }

        if changes == 0 {
            println!("Converged!");
            break;
        }
    }

    // 4. Verify Results
    let hypotheses = ctx.get(ContextKey::Hypotheses);
    if let Some(hypo) = hypotheses.first() {
        println!("\nFinal Result: {}", hypo.content);
    } else {
        println!("\nNo hypothesis generated.");
    }

    Ok(())
}

Trait Implementations

impl Agent for InferenceAgent

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.