Struct FewShotPromptTemplate 

pub struct FewShotPromptTemplate { /* private fields */ }

A string-based few-shot prompt template (as opposed to FewShotChatMessagePromptTemplate which produces Vec<Message>).

Produces a single formatted string with examples embedded.

Implementations

impl FewShotPromptTemplate

pub fn new( examples: Vec<FewShotExample>, example_prompt: PromptTemplate, suffix: PromptTemplate, ) -> Self

Create a new string-based few-shot template.

• examples: the input/output example pairs
• example_prompt: template for each example, e.g. "Input: {{ input }}\nOutput: {{ output }}"
• suffix: final template rendered with user-provided variables

pub fn with_prefix(self, prefix: impl Into<String>) -> Self

Set an optional prefix string prepended before the examples.

pub fn with_separator(self, sep: impl Into<String>) -> Self

Set the separator used between examples (default: "\n\n").

pub fn render( &self, values: &HashMap<String, String>, ) -> Result<String, SynapticError>

Render the template with the given variable values.

1. Start with prefix (if any)
2. For each example, render example_prompt with {"input": ..., "output": ...}
3. Join examples with separator
4. Append suffix rendered with provided values
5. Join all parts with separator

Trait Implementations

impl Runnable<HashMap<String, String>, String> for FewShotPromptTemplate

fn invoke<'life0, 'life1, 'async_trait>( &'life0 self, input: HashMap<String, String>, _config: &'life1 RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<String, SynapticError>> + Send + 'async_trait>>

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

Execute this runnable on a single input.

fn batch<'life0, 'life1, 'async_trait>( &'life0 self, inputs: Vec<I>, config: &'life1 RunnableConfig, ) -> Pin<Box<dyn Future<Output = Vec<Result<O, SynapticError>>> + Send + 'async_trait>>

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

Execute this runnable on multiple inputs sequentially.

fn stream<'a>( &'a self, input: I, config: &'a RunnableConfig, ) -> Pin<Box<dyn Stream<Item = Result<O, SynapticError>> + Send + 'a>>

where I: 'a,

Stream the output. Default wraps invoke as a single-item stream. Override for true streaming (e.g., token-by-token from an LLM).

fn boxed(self) -> BoxRunnable<I, O>

where Self: Sized + 'static,

Wrap this runnable into a type-erased BoxRunnable for composition via |.