Struct RefineDocuments 

pub struct RefineDocuments { /* private fields */ }

Combines documents by running a chain on the first one, then refining that answer with each following document in turn.

Good when the documents don’t fit in one prompt and order matters, or when you want the answer to build up as the model reads. It makes one LLM call per document, sequentially.

Inputs: input_documents (a Vec<Document>) plus whatever the prompts use (e.g. question). The initial chain gets each document as context; the refine chain also gets the previous answer as existing_answer.

let chain = RefineDocuments::load_summarize(OpenAI::default());
let summary = chain
    .invoke(prompt_args! { "input_documents" => docs })
    .await?;

Implementations

impl RefineDocuments

pub fn new<C1: Into<Box<dyn Chain>>, C2: Into<Box<dyn Chain>>>( initial_chain: C1, refine_chain: C2, ) -> Self

initial_chain answers from the first document; refine_chain takes existing_answer and the next document and returns an improved answer.

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

Input key holding the documents (default input_documents).

pub fn with_document_variable_name<S: Into<String>>(self, name: S) -> Self

Prompt variable each document’s text is passed as (default context).

pub fn with_initial_response_name<S: Into<String>>(self, name: S) -> Self

Prompt variable the previous answer is passed as (default existing_answer).

impl RefineDocuments

pub fn load_qa<L: Into<Box<dyn LLM>>>(llm: L) -> Self

Answers question from the first document, then refines the answer with each of the others. Inputs: input_documents, question.

pub fn load_summarize<L: Into<Box<dyn LLM>>>(llm: L) -> Self

Summarizes the first document, then refines the summary with each of the others. Input: input_documents.

Trait Implementations

impl Chain for RefineDocuments

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

Runs the intermediate steps quietly and streams the final refinement.

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 get_input_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 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 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 get_output_keys(&self) -> Vec<String>