Struct RunnableWithMessageHistory 

pub struct RunnableWithMessageHistory<L> { /* private fields */ }

LLM wrapper with memory, participating in LCEL composition as a single Runnable.

Implementations

impl<L> RunnableWithMessageHistory<L>

pub fn new(llm: L, memory: impl BaseMemory + 'static) -> Self

Builds the wrapper from an LLM + a single memory object (all calls share this memory).

pub fn with_session_history<F>(llm: L, factory: F) -> Self

where F: Fn(&str) -> SharedMemory + Send + Sync + 'static,

Builds the wrapper from an LLM + a session callback (mirrors Python’s RunnableWithMessageHistory(llm, get_session_history)).

factory(session_id) builds a memory object for one session slot; each call selects the slot by config.configurable["session_id"], and the same session reuses its built slot.

Example

let pipe = RunnableWithMessageHistory::with_session_history(llm, |session_id| {
    Arc::new(Mutex::new(Box::new(
        ConversationBufferMemory::new().with_return_messages(true),
    ) as Box<dyn BaseMemory>))
});
let cfg = RunnableConfig::new().with_configurable("session_id", json!("s1"));
pipe.invoke("我叫小明".into(), Some(cfg)).await?;

pub fn with_max_sessions(self, max: usize) -> Self

Sets the session-cache cap (Sessions mode). When exceeded, a new session evicts the oldest slot, preventing a memory DoS from unbounded session_id growth (M2a). Defaults to DEFAULT_MAX_SESSIONS.

pub fn memory(&self) -> SharedMemory

Exposes the internal memory handle for reading saved history (debugging, display, verifying write-back, etc.).

In Sessions mode the slot is not unique, so a placeholder memory is returned (it does not participate in pipeline reads/writes); to inspect real history, read from the pipeline internals or the business-side memory object.

Trait Implementations

impl<L> Runnable<String, LLMResult> for RunnableWithMessageHistory<L>

where L: BaseChatModel + 'static, L::Error: Into<LcelError>,

type Error = LcelError

Error type.

fn invoke<'life0, 'async_trait>( &'life0 self, input: String, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<LLMResult, LcelError>> + Send + 'async_trait>>

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

Transforms single input to output.

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

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

Batch processing - transforms multiple inputs to outputs.

fn batch_as_completed<'life0, 'async_trait>( &'life0 self, inputs: Vec<Input>, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(usize, Output)>, Self::Error>> + Send + 'async_trait>>

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

Batch processing that returns results in completion order.

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

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

Streaming output - for real-time responses (LLM, etc).

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

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

Stream-to-stream transformation - the core of LCEL streaming.