Struct RouterChain 

pub struct RouterChain { /* private fields */ }

Asks an LLM which of several named chains should handle the input, then runs that chain with the same input. If none fits (or the LLM names one that doesn’t exist), the default chain runs; without a default that’s an error.

For routing by embeddings instead of an LLM call, see semantic_router.

let router = RouterChainBuilder::new()
    .llm(OpenAI::default())
    .destination("physics", "Questions about physics", physics_chain)
    .destination("math", "Math problems and proofs", math_chain)
    .default_chain(general_chain)
    .build()?;
let answer = router.invoke(prompt_args! { "input" => "What is a black hole?" }).await?;

Implementations

impl RouterChain

pub async fn route( &self, input_variables: &PromptArgs, ) -> Result<Route, ChainError>

Asks the LLM where input_variables should go, without running anything else.

Trait Implementations

impl Chain for RouterChain

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,

The destination’s own outputs, plus the answer under the output key, the full result (routing tokens included) and ROUTER_DESTINATION_KEY.

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

Routes, then streams the destination’s answer. The final Done includes the routing tokens.

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