Struct RunnableSequence 

pub struct RunnableSequence<R1, R2>
where
    R1: Runnable,
    R2: Runnable<Input = R1::Output>,
{ /* private fields */ }

A sequence of Runnables that are executed one after another.

The output of one Runnable is the input to the next. This is the most common composition pattern in LangChain.

Implementations

impl<R1, R2> RunnableSequence<R1, R2>

where R1: Runnable, R2: Runnable<Input = R1::Output>,

pub fn new(first: R1, last: R2) -> Self

Create a new RunnableSequence.

pub fn with_name(self, name: impl Into<String>) -> Self

Create a new RunnableSequence with a name.

Trait Implementations

impl<R1, R2> Debug for RunnableSequence<R1, R2>

where R1: Runnable, R2: Runnable<Input = R1::Output>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R1, R2> Runnable for RunnableSequence<R1, R2>

where R1: Runnable + 'static, R2: Runnable<Input = R1::Output> + 'static,

type Input = <R1 as Runnable>::Input

The input type for this Runnable.

type Output = <R2 as Runnable>::Output

The output type for this Runnable.

fn name(&self) -> Option<String>

Get the optional name of this Runnable.

fn invoke( &self, input: Self::Input, config: Option<RunnableConfig>, ) -> Result<Self::Output>

Transform a single input into an output.

fn ainvoke<'life0, 'async_trait>( &'life0 self, input: Self::Input, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Self::Output>> + Send + 'async_trait>>

where Self: 'static + 'async_trait, 'life0: 'async_trait,

Transform a single input into an output asynchronously.

fn stream( &self, input: Self::Input, config: Option<RunnableConfig>, ) -> BoxStream<'_, Result<Self::Output>>

Stream output from a single input.

fn get_name(&self, suffix: Option<&str>, name: Option<&str>) -> String

Get the name of this Runnable.

fn type_name(&self) -> &'static str

Get the type name of this Runnable.

fn batch( &self, inputs: Vec<Self::Input>, config: Option<ConfigOrList>, _return_exceptions: bool, ) -> Vec<Result<Self::Output>>

where Self: 'static,

Transform multiple inputs into outputs in parallel.

fn abatch<'life0, 'async_trait>( &'life0 self, inputs: Vec<Self::Input>, config: Option<ConfigOrList>, _return_exceptions: bool, ) -> Pin<Box<dyn Future<Output = Vec<Result<Self::Output>>> + Send + 'async_trait>>

where Self: 'static + 'async_trait, 'life0: 'async_trait,

Transform multiple inputs into outputs asynchronously.

fn astream( &self, input: Self::Input, config: Option<RunnableConfig>, ) -> BoxStream<'_, Result<Self::Output>>

where Self: 'static,

Stream output from a single input asynchronously.

fn transform<'a>( &'a self, input: BoxStream<'a, Self::Input>, config: Option<RunnableConfig>, ) -> BoxStream<'a, Result<Self::Output>>

Transform an input stream into an output stream.

fn atransform<'a>( &'a self, input: BoxStream<'a, Self::Input>, config: Option<RunnableConfig>, ) -> BoxStream<'a, Result<Self::Output>>

where Self: 'static,

Transform an input stream into an output stream asynchronously.

fn bind(self, kwargs: HashMap<String, Value>) -> RunnableBinding<Self>

where Self: Sized,

Bind arguments to this Runnable, returning a new Runnable.

fn with_config(self, config: RunnableConfig) -> RunnableBinding<Self>

where Self: Sized,

Bind config to this Runnable, returning a new Runnable.

fn with_retry( self, max_attempts: usize, wait_exponential_jitter: bool, ) -> RunnableRetry<Self>

where Self: Sized,

Create a new Runnable that retries on failure.

fn map(self) -> RunnableEach<Self>

where Self: Sized,

Return a new Runnable that maps a list of inputs to a list of outputs.