Struct ConstitutionalChain 

pub struct ConstitutionalChain { /* private fields */ }

Runs a chain, then for each principle asks the model to critique the answer and, when the critique finds a problem, to revise it. Each revision is what the next principle critiques.

let chain = ConstitutionalChain::new(
    qa_chain,
    llm,
    vec![ConstitutionalPrinciple::get("illegal").unwrap()],
);
let answer = chain.invoke(prompt_args! { "question" => "..." }).await?;

Implementations

impl ConstitutionalChain

pub fn new<L: Into<Box<dyn LLM>>>( chain: LLMChain, llm: L, principles: Vec<ConstitutionalPrinciple>, ) -> Self

chain answers first; llm writes the critiques and revisions with the built-in few-shot prompts.

pub fn with_critique_chain<C: Into<Box<dyn Chain>>>(self, chain: C) -> Self

Replaces the critique step. It gets input_prompt, output_from_model and critique_request; an output containing “No critique needed” skips the revision.

pub fn with_revision_chain<C: Into<Box<dyn Chain>>>(self, chain: C) -> Self

Replaces the revision step. It gets the critique step’s inputs plus critique and revision_request.

pub fn with_output_key<S: Into<String>>(self, key: S) -> Self

Key of the final answer in execute’s output (default output).

pub fn with_return_intermediate_steps(self, enabled: bool) -> Self

Also return the first answer and every CritiqueRevision from execute, under CONSTITUTIONAL_INITIAL_OUTPUT_KEY and CONSTITUTIONAL_STEPS_KEY.

pub async fn critique_and_revise( &self, input_variables: PromptArgs, ) -> Result<ConstitutionalOutput, ChainError>

Runs the chain and every principle, returning all the steps.

Trait Implementations

impl Chain for ConstitutionalChain

fn call<'life0, 'async_trait>( &'life0 self, input_variables: PromptArgs, ) -> Pin<Box<dyn Future<Output = Result<GenerateResult, ChainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Call the Chain and receive as output the result of the generation process along with additional information like token consumption. The input is a set of variables passed as a PromptArgs hashmap.

fn execute<'life0, 'async_trait>( &'life0 self, input_variables: PromptArgs, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Value>, ChainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute the Chain and return the result of the generation process along with additional information like token consumption formatted as a HashMap. The input is a set of variables passed as a PromptArgs hashmap. The key for the generated output is specified by the get_output_keys method (default key is output).

fn get_input_keys(&self) -> Vec<String>

fn get_output_keys(&self) -> Vec<String>

fn invoke<'life0, 'async_trait>( &'life0 self, input_variables: PromptArgs, ) -> Pin<Box<dyn Future<Output = Result<String, ChainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Invoke the Chain and receive just the generation result as a String. The input is a set of variables passed as a PromptArgs hashmap.

fn stream<'life0, 'async_trait>( &'life0 self, _input_variables: PromptArgs, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<StreamData, ChainError>> + Send>>, ChainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stream the Chain and get an asynchronous stream of chain generations. The input is a set of variables passed as a PromptArgs hashmap. If the chain have memroy, the tream method will not be able to automaticaly set the memroy, bocause it will not know if the how to extract the output message out of the stram

fn call_stream<'a>( &'a self, input_variables: PromptArgs, ) -> ChainEventStream<'a>

Like call, but streams the LLM output as LLMEvents: Text chunks, then one Done with the complete result.