Struct PredictModule 

pub struct PredictModule<'a, L: Llm, V: Validate = NoValidation> { /* private fields */ }

A simple composable module that wraps an LLM call with optional demos.

PredictModule implements ComposableModule with:

• Input: &'a str (the prompt)
• Output: String (the LLM response)

It stores an instruction, optional validator, and few-shot demos that are prepended to the prompt.

Examples

use kkachi::composable::PredictModule;
use kkachi::recursive::{MockLlm, NoValidation};

let llm = MockLlm::new(|p, _| format!("response to: {}", p));
let module = PredictModule::new("predict", &llm, "Answer the question.");

// Use as a ComposableModule
let output = module.forward("What is 2+2?").await.unwrap();
assert!(output.contains("response to:"));

Implementations

impl<'a, L: Llm> PredictModule<'a, L, NoValidation>

pub fn new(name: &'a str, llm: &'a L, instruction: impl Into<String>) -> Self

Create a new predict module with no validator.

impl<'a, L: Llm, V: Validate> PredictModule<'a, L, V>

pub fn validate<V2: Validate>(self, validator: V2) -> PredictModule<'a, L, V2>

Set a validator, returning a new module with the validator type changed.

pub fn demo(self, input: impl Into<String>, output: impl Into<String>) -> Self

Add a few-shot demonstration example.

pub fn instruction(self, instruction: impl Into<String>) -> Self

Set the instruction.

pub fn save_composable_state(&self) -> ModuleState<'_>

Save composable state (instruction + demos).

pub fn load_composable_state(&mut self, state: &ModuleState<'_>) -> bool

Load composable state (instruction + demos).

Returns true if the state name matched and was applied.

Trait Implementations

impl<'a, L, V> ComposableModule for PredictModule<'a, L, V>

where L: Llm + 'static, V: Validate + 'static,

type Input<'b> = &'b str where Self: 'b

Input type for this module. The lifetime allows borrowing from the caller.

type Output<'b> = String where Self: 'b

Output type for this module. The lifetime allows borrowing from self.

type ForwardFut<'b> = Pin<Box<dyn Future<Output = Result<String, Error>> + Send + 'b>> where Self: 'b

Future returned by forward.

fn forward<'b>(&'b self, input: Self::Input<'b>) -> Self::ForwardFut<'b>

Execute the module on the given input.

fn name(&self) -> &str

Human-readable name for this module (used in state trees and logging).

fn save_state(&self) -> ModuleState<'_>

Snapshot the module’s learnable state (instruction, demos, children).

fn load_state(&mut self, state: &ModuleState<'_>) -> bool

Restore learnable state from a snapshot.