Struct MapReduceDocuments 

pub struct MapReduceDocuments { /* private fields */ }

Combines documents in two phases: a map chain runs on every document independently (concurrently), then a reduce chain combines the mapped outputs.

Good for documents too large to fit in one prompt together, when each one can be processed on its own (summaries, extracting relevant passages).

Inputs: input_documents (a Vec<Document>) plus whatever the prompts use (e.g. question). The map chain gets each document’s text as context. The reduce chain gets the mapped outputs as input_documents (keeping each source document’s metadata), so a StuffDocument works as the reduce chain.

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

Implementations

impl MapReduceDocuments

pub fn new<M: Into<Box<dyn Chain>>, R: Into<Box<dyn Chain>>>( map_chain: M, reduce_chain: R, ) -> Self

map_chain runs once per document; reduce_chain combines the results.

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 the map chain receives each document’s text as (default context).

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

Input key the reduce chain receives the mapped documents in (default input_documents).

pub fn with_max_concurrency(self, max_concurrency: usize) -> Self

How many map calls run at the same time (default 5, minimum 1).

impl MapReduceDocuments

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

Extracts the passages relevant to question from each document, then answers from those. Inputs: input_documents, question.

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

Summarizes each document, then summarizes the summaries. Input: input_documents.

Trait Implementations

impl Chain for MapReduceDocuments

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

Runs the map phase quietly and streams the reduce step.

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>