Struct RetrievalQA 

pub struct RetrievalQA { /* private fields */ }

Question answering over a Retriever: fetches the documents relevant to the query, then hands them with the question to a document-combining chain.

Stateless, unlike ConversationalRetrieverChain: no memory, no question rephrasing. The combining chain receives input_documents and question, so StuffDocument, RefineDocuments and MapReduceDocuments QA chains all fit.

let qa = RetrievalQA::from_llm(OpenAI::default(), store_retriever);
let answer = qa.invoke(prompt_args! { "query" => "What is our refund policy?" }).await?;

Implementations

impl RetrievalQA

pub fn new<R: Into<Box<dyn Retriever>>, C: Into<Box<dyn Chain>>>( retriever: R, combine_documents_chain: C, ) -> Self

pub fn from_llm<L: Into<Box<dyn LLM>>, R: Into<Box<dyn Retriever>>>( llm: L, retriever: R, ) -> Self

Stuffs every retrieved document into one QA prompt.

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

Input key holding the query (default query).

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

Output key of the answer in execute (default output).

pub fn with_return_source_documents(self, yes: bool) -> Self

Adds the retrieved documents to execute’s output under RETRIEVAL_QA_SOURCE_DOCUMENTS_KEY.

Trait Implementations

impl Chain for RetrievalQA

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

Retrieves, then streams the combining chain’s answer.

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