Struct AdaptiveRAG 

pub struct AdaptiveRAG<M: BaseChatModel, R: RetrieverTrait> { /* private fields */ }

Adaptive RAG that routes queries to the most appropriate strategy.

Overview

1. The LLM classifies the query into one of three buckets: no_retrieval, single_search, or multi_query.
2. Based on the decision:
   • NoRetrieval: call the LLM directly.
   • SingleSearch: retrieve documents, then generate.
   • MultiQuery: generate multiple query variants, retrieve for each, merge results, then generate.

Example

use langchainrust::agents::adaptive_rag::{AdaptiveRAG, RagDecision};
use langchainrust::OpenAIChat;
use langchainrust::retrieval::SimilarityRetriever;

let rag = AdaptiveRAG::new(llm, retriever);
let result = rag.invoke("What is the capital of France?").await?;
assert_eq!(result.decision, RagDecision::NoRetrieval);

Implementations

impl<M: BaseChatModel, R: RetrieverTrait> AdaptiveRAG<M, R>

pub fn new(llm: M, retriever: R) -> Self

Creates a new AdaptiveRAG with the given LLM and retriever.

pub fn with_retrieve_k(self, k: usize) -> Self

Sets the number of documents to retrieve per query.

pub fn with_multi_query_count(self, count: usize) -> Self

Sets the number of alternative queries for multi-query mode.

pub async fn invoke( &self, query: &str, ) -> Result<AdaptiveRAGResult, AdaptiveRAGError>

Invokes the adaptive RAG pipeline for the given query.

pub async fn stream( &self, query: &str, ) -> Result<Pin<Box<dyn Stream<Item = AgentStreamEvent> + Send>>, AdaptiveRAGError>

Streams the AdaptiveRAG execution, emitting pipeline step events.

Emits AgentStreamEvent::PipelineStep events for routing and generation, and AgentStreamEvent::FinalAnswer when the answer is ready.

Trait Implementations

impl<M, R> Orchestrator for AdaptiveRAG<M, R>

where M: BaseChatModel + Send + Sync, M::Error: Send + Sync, R: RetrieverTrait + Send + Sync,

type Input = String

Input type (usually a String objective/question).

type Output = AdaptiveRAGResult

Output type.

fn run_with_context<'life0, 'life1, 'async_trait>( &'life0 self, input: Self::Input, ctx: &'life1 RunContext, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, AgentError>> + Send + 'async_trait>>

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

Execution entry point carrying the run context.