Struct MapRerankDocuments 

pub struct MapRerankDocuments { /* private fields */ }

Answers from every document separately, asking the model to score each answer, and returns the best one.

Good for questions whose answer sits in one document (a FAQ entry, a product page), where mixing documents would blur it. It makes one LLM call per document, concurrently.

Inputs: input_documents (a Vec<Document>) plus whatever the prompt uses (e.g. question). The chain gets each document’s text as context and must end its output with Score: <0-100>, like the prompt of load_qa asks.

Outputs without a score rank below every scored one; if no output has a score the chain fails. Ties keep document order.

let chain = MapRerankDocuments::load_qa(OpenAI::default());
let answer = chain
    .invoke(prompt_args! { "input_documents" => docs, "question" => "Who wrote it?" })
    .await?;

Implementations

impl MapRerankDocuments

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

map_chain runs once per document and must answer with a trailing Score:.

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

Input key holding the documents (default input_documents).

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

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

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

Prompt variable each document’s text goes in (default context).

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

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

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

Also return every document’s RankedAnswer (in document order) from execute, under MAP_RERANK_INTERMEDIATE_STEPS_KEY.

pub async fn rank( &self, input_variables: &PromptArgs, ) -> Result<(Vec<RankedAnswer>, usize, Option<TokenUsage>), ChainError>

Answers from every document and returns the answers in document order, the index of the best one, and the usage of all calls.

impl MapRerankDocuments

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

Answers question from each document with a self-reported score and returns the best-scored answer. Inputs: input_documents, question.

Trait Implementations

impl Chain for MapRerankDocuments

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,

Returns the best answer under the output key, its score under MAP_RERANK_SCORE_KEY, and optionally every answer under MAP_RERANK_INTERMEDIATE_STEPS_KEY.

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 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.