Struct ChainRunner 

pub struct ChainRunner<'a> { /* private fields */ }

A fluent builder to define and execute a multi-step prompt chain.

Implementations

impl<'a> ChainRunner<'a>

pub fn step(self, output_key: &str, prompt_id_or_title: &str) -> Self

Adds a sequential step from the store.

Examples found in repository

examples/advanced_chain_example.rs (line 64)

async fn run_chain(
    store: &PromptStore,
    registry: &LLMRegistry,
    feedback: &str,
) -> Result<RunOutput, RunError> {
    store
        .chain(registry)
        // Step 1: Always run sentiment analysis.
        .step("sentiment", "Sentiment Check")
            .with_provider("openai")
        // Step 2 (Conditional): Only run if the sentiment is "positive".
        .step_if("positive_reply", "Positive Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("positive"))
        })
            .with_provider("openai")

        // Step 3 (Conditional): Only run if the sentiment is "negative".
        .step_if("negative_reply", "Negative Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("negative"))
        })
            .with_provider("openai")

        .vars([("feedback", feedback)])
        .run()
        .await
}

examples/parallel_example.rs (line 37)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

examples/chain_example.rs (line 53)

async fn main() -> Result<(), RunError> {
    // 1. Initialize the store once. This loads keys and configuration.
    // Or use with_password("password") to use a password to decrypt the vault of the prompts.
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    // 2. Set up the LLM providers and a registry to hold them.
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .max_tokens(1000)
        .build()
        .unwrap();

    let anthropic_llm = LLMBuilder::new()
        .backend(LLMBackend::Anthropic)
        .api_key(std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set"))
        .model("claude-3-5-sonnet-20240620")
        .max_tokens(1000)
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai_fast", openai_llm);
    registry.insert("anthropic_strong", anthropic_llm);

    // 3. Define and run the chain fluently, loading prompts from the store.
    let user_question = "How does photosynthesis work at the molecular level?";

    println!("Executing prompt chain for: \"{}\"", user_question);

    let outputs = store
        .chain(&registry) // Start a chain with the provider registry.
        // Step 1: uses the prompt with id "9k6zezem".
        // Its output will be available as the `{{analyse}}` variable.
        .step("analyse", "9k6zezem")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("openai_fast")
        // Step 2: uses the prompt with id "uetgwnq1".
        // It implicitly uses the `{{analyse}}` output from the previous step.
        .step("suggestions", "uetgwnq1")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Step 3: uses the prompt with id "dkeodfyp".
        // It can use both the initial `{{query}}` and `{{suggestions}}`.
        .step("final_response", "dkeodfyp")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        .step_raw(
            "raw",
            "Synthesize the following: {{final_response}} in 2 sentences.",
        )
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Provide the initial variable for the first step.
        .vars([("query", user_question)])
        .run()
        .await?;

    // 4. Process the results.
    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!(
            "\n[✅] Final Answer (from 'final_response' step):\n{}",
            map.get("final_response").unwrap_or(&"N/A".to_string())
        );
        println!("\n--- Intermediate Steps ---");
        println!(
            "\n[1] Analysis ('analyse'):\n{}",
            map.get("analyse").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[2] Suggestions ('suggestions'):\n{}",
            map.get("suggestions").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[3] Raw ('raw'):\n{}",
            map.get("raw").unwrap_or(&"N/A".to_string())
        );
    }

    Ok(())
}

pub fn step_raw(self, output_key: &str, prompt_content: &str) -> Self

Adds a sequential step with a raw prompt.

Examples found in repository

examples/chain_example.rs (lines 66-69)

async fn main() -> Result<(), RunError> {
    // 1. Initialize the store once. This loads keys and configuration.
    // Or use with_password("password") to use a password to decrypt the vault of the prompts.
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    // 2. Set up the LLM providers and a registry to hold them.
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .max_tokens(1000)
        .build()
        .unwrap();

    let anthropic_llm = LLMBuilder::new()
        .backend(LLMBackend::Anthropic)
        .api_key(std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set"))
        .model("claude-3-5-sonnet-20240620")
        .max_tokens(1000)
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai_fast", openai_llm);
    registry.insert("anthropic_strong", anthropic_llm);

    // 3. Define and run the chain fluently, loading prompts from the store.
    let user_question = "How does photosynthesis work at the molecular level?";

    println!("Executing prompt chain for: \"{}\"", user_question);

    let outputs = store
        .chain(&registry) // Start a chain with the provider registry.
        // Step 1: uses the prompt with id "9k6zezem".
        // Its output will be available as the `{{analyse}}` variable.
        .step("analyse", "9k6zezem")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("openai_fast")
        // Step 2: uses the prompt with id "uetgwnq1".
        // It implicitly uses the `{{analyse}}` output from the previous step.
        .step("suggestions", "uetgwnq1")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Step 3: uses the prompt with id "dkeodfyp".
        // It can use both the initial `{{query}}` and `{{suggestions}}`.
        .step("final_response", "dkeodfyp")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        .step_raw(
            "raw",
            "Synthesize the following: {{final_response}} in 2 sentences.",
        )
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Provide the initial variable for the first step.
        .vars([("query", user_question)])
        .run()
        .await?;

    // 4. Process the results.
    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!(
            "\n[✅] Final Answer (from 'final_response' step):\n{}",
            map.get("final_response").unwrap_or(&"N/A".to_string())
        );
        println!("\n--- Intermediate Steps ---");
        println!(
            "\n[1] Analysis ('analyse'):\n{}",
            map.get("analyse").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[2] Suggestions ('suggestions'):\n{}",
            map.get("suggestions").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[3] Raw ('raw'):\n{}",
            map.get("raw").unwrap_or(&"N/A".to_string())
        );
    }

    Ok(())
}

pub fn step_if<F>( self, output_key: &str, prompt_id_or_title: &str, condition: F, ) -> Self

where F: Fn(&HashMap<String, String>) -> bool + Send + Sync + 'a,

Adds a conditional step from the store. It runs only if the condition is met.

Examples found in repository

examples/advanced_chain_example.rs (lines 67-69)

async fn run_chain(
    store: &PromptStore,
    registry: &LLMRegistry,
    feedback: &str,
) -> Result<RunOutput, RunError> {
    store
        .chain(registry)
        // Step 1: Always run sentiment analysis.
        .step("sentiment", "Sentiment Check")
            .with_provider("openai")
        // Step 2 (Conditional): Only run if the sentiment is "positive".
        .step_if("positive_reply", "Positive Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("positive"))
        })
            .with_provider("openai")

        // Step 3 (Conditional): Only run if the sentiment is "negative".
        .step_if("negative_reply", "Negative Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("negative"))
        })
            .with_provider("openai")

        .vars([("feedback", feedback)])
        .run()
        .await
}

examples/parallel_example.rs (lines 52-55)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

pub fn parallel<F>(self, build_group: F) -> Self

where F: for<'b> FnOnce(ParallelGroupBuilder<'b>) -> ParallelGroupBuilder<'b>,

Adds a group of steps that will be executed in parallel.

Examples found in repository

examples/parallel_example.rs (lines 40-46)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

pub fn on_error_stored(self, fallback_id_or_title: &str) -> Self

Sets a fallback prompt from the store for the last added step. This is executed if the primary prompt execution fails.

Examples found in repository

examples/parallel_example.rs (line 49)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

pub fn on_error_raw(self, fallback_content: &str) -> Self

Sets a raw fallback prompt for the last added step.

pub fn with_provider(self, provider_id: &str) -> Self

Specifies the provider for the last added step or all steps in the last parallel group.

Examples found in repository

examples/advanced_chain_example.rs (line 65)

async fn run_chain(
    store: &PromptStore,
    registry: &LLMRegistry,
    feedback: &str,
) -> Result<RunOutput, RunError> {
    store
        .chain(registry)
        // Step 1: Always run sentiment analysis.
        .step("sentiment", "Sentiment Check")
            .with_provider("openai")
        // Step 2 (Conditional): Only run if the sentiment is "positive".
        .step_if("positive_reply", "Positive Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("positive"))
        })
            .with_provider("openai")

        // Step 3 (Conditional): Only run if the sentiment is "negative".
        .step_if("negative_reply", "Negative Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("negative"))
        })
            .with_provider("openai")

        .vars([("feedback", feedback)])
        .run()
        .await
}

examples/parallel_example.rs (line 38)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

examples/chain_example.rs (line 55)

async fn main() -> Result<(), RunError> {
    // 1. Initialize the store once. This loads keys and configuration.
    // Or use with_password("password") to use a password to decrypt the vault of the prompts.
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    // 2. Set up the LLM providers and a registry to hold them.
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .max_tokens(1000)
        .build()
        .unwrap();

    let anthropic_llm = LLMBuilder::new()
        .backend(LLMBackend::Anthropic)
        .api_key(std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set"))
        .model("claude-3-5-sonnet-20240620")
        .max_tokens(1000)
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai_fast", openai_llm);
    registry.insert("anthropic_strong", anthropic_llm);

    // 3. Define and run the chain fluently, loading prompts from the store.
    let user_question = "How does photosynthesis work at the molecular level?";

    println!("Executing prompt chain for: \"{}\"", user_question);

    let outputs = store
        .chain(&registry) // Start a chain with the provider registry.
        // Step 1: uses the prompt with id "9k6zezem".
        // Its output will be available as the `{{analyse}}` variable.
        .step("analyse", "9k6zezem")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("openai_fast")
        // Step 2: uses the prompt with id "uetgwnq1".
        // It implicitly uses the `{{analyse}}` output from the previous step.
        .step("suggestions", "uetgwnq1")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Step 3: uses the prompt with id "dkeodfyp".
        // It can use both the initial `{{query}}` and `{{suggestions}}`.
        .step("final_response", "dkeodfyp")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        .step_raw(
            "raw",
            "Synthesize the following: {{final_response}} in 2 sentences.",
        )
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Provide the initial variable for the first step.
        .vars([("query", user_question)])
        .run()
        .await?;

    // 4. Process the results.
    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!(
            "\n[✅] Final Answer (from 'final_response' step):\n{}",
            map.get("final_response").unwrap_or(&"N/A".to_string())
        );
        println!("\n--- Intermediate Steps ---");
        println!(
            "\n[1] Analysis ('analyse'):\n{}",
            map.get("analyse").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[2] Suggestions ('suggestions'):\n{}",
            map.get("suggestions").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[3] Raw ('raw'):\n{}",
            map.get("raw").unwrap_or(&"N/A".to_string())
        );
    }

    Ok(())
}

pub fn with_mode(self, mode: MultiChainStepMode) -> Self

Sets the execution mode for the last added step.

Examples found in repository

examples/chain_example.rs (line 54)

async fn main() -> Result<(), RunError> {
    // 1. Initialize the store once. This loads keys and configuration.
    // Or use with_password("password") to use a password to decrypt the vault of the prompts.
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    // 2. Set up the LLM providers and a registry to hold them.
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .max_tokens(1000)
        .build()
        .unwrap();

    let anthropic_llm = LLMBuilder::new()
        .backend(LLMBackend::Anthropic)
        .api_key(std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set"))
        .model("claude-3-5-sonnet-20240620")
        .max_tokens(1000)
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai_fast", openai_llm);
    registry.insert("anthropic_strong", anthropic_llm);

    // 3. Define and run the chain fluently, loading prompts from the store.
    let user_question = "How does photosynthesis work at the molecular level?";

    println!("Executing prompt chain for: \"{}\"", user_question);

    let outputs = store
        .chain(&registry) // Start a chain with the provider registry.
        // Step 1: uses the prompt with id "9k6zezem".
        // Its output will be available as the `{{analyse}}` variable.
        .step("analyse", "9k6zezem")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("openai_fast")
        // Step 2: uses the prompt with id "uetgwnq1".
        // It implicitly uses the `{{analyse}}` output from the previous step.
        .step("suggestions", "uetgwnq1")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Step 3: uses the prompt with id "dkeodfyp".
        // It can use both the initial `{{query}}` and `{{suggestions}}`.
        .step("final_response", "dkeodfyp")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        .step_raw(
            "raw",
            "Synthesize the following: {{final_response}} in 2 sentences.",
        )
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Provide the initial variable for the first step.
        .vars([("query", user_question)])
        .run()
        .await?;

    // 4. Process the results.
    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!(
            "\n[✅] Final Answer (from 'final_response' step):\n{}",
            map.get("final_response").unwrap_or(&"N/A".to_string())
        );
        println!("\n--- Intermediate Steps ---");
        println!(
            "\n[1] Analysis ('analyse'):\n{}",
            map.get("analyse").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[2] Suggestions ('suggestions'):\n{}",
            map.get("suggestions").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[3] Raw ('raw'):\n{}",
            map.get("raw").unwrap_or(&"N/A".to_string())
        );
    }

    Ok(())
}

pub fn vars( self, vars: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>, ) -> Self

Sets initial variables for the chain.

Examples found in repository

examples/advanced_chain_example.rs (line 78)

async fn run_chain(
    store: &PromptStore,
    registry: &LLMRegistry,
    feedback: &str,
) -> Result<RunOutput, RunError> {
    store
        .chain(registry)
        // Step 1: Always run sentiment analysis.
        .step("sentiment", "Sentiment Check")
            .with_provider("openai")
        // Step 2 (Conditional): Only run if the sentiment is "positive".
        .step_if("positive_reply", "Positive Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("positive"))
        })
            .with_provider("openai")

        // Step 3 (Conditional): Only run if the sentiment is "negative".
        .step_if("negative_reply", "Negative Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("negative"))
        })
            .with_provider("openai")

        .vars([("feedback", feedback)])
        .run()
        .await
}

examples/parallel_example.rs (line 57)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

examples/chain_example.rs (line 73)

async fn main() -> Result<(), RunError> {
    // 1. Initialize the store once. This loads keys and configuration.
    // Or use with_password("password") to use a password to decrypt the vault of the prompts.
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    // 2. Set up the LLM providers and a registry to hold them.
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .max_tokens(1000)
        .build()
        .unwrap();

    let anthropic_llm = LLMBuilder::new()
        .backend(LLMBackend::Anthropic)
        .api_key(std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set"))
        .model("claude-3-5-sonnet-20240620")
        .max_tokens(1000)
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai_fast", openai_llm);
    registry.insert("anthropic_strong", anthropic_llm);

    // 3. Define and run the chain fluently, loading prompts from the store.
    let user_question = "How does photosynthesis work at the molecular level?";

    println!("Executing prompt chain for: \"{}\"", user_question);

    let outputs = store
        .chain(&registry) // Start a chain with the provider registry.
        // Step 1: uses the prompt with id "9k6zezem".
        // Its output will be available as the `{{analyse}}` variable.
        .step("analyse", "9k6zezem")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("openai_fast")
        // Step 2: uses the prompt with id "uetgwnq1".
        // It implicitly uses the `{{analyse}}` output from the previous step.
        .step("suggestions", "uetgwnq1")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Step 3: uses the prompt with id "dkeodfyp".
        // It can use both the initial `{{query}}` and `{{suggestions}}`.
        .step("final_response", "dkeodfyp")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        .step_raw(
            "raw",
            "Synthesize the following: {{final_response}} in 2 sentences.",
        )
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Provide the initial variable for the first step.
        .vars([("query", user_question)])
        .run()
        .await?;

    // 4. Process the results.
    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!(
            "\n[✅] Final Answer (from 'final_response' step):\n{}",
            map.get("final_response").unwrap_or(&"N/A".to_string())
        );
        println!("\n--- Intermediate Steps ---");
        println!(
            "\n[1] Analysis ('analyse'):\n{}",
            map.get("analyse").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[2] Suggestions ('suggestions'):\n{}",
            map.get("suggestions").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[3] Raw ('raw'):\n{}",
            map.get("raw").unwrap_or(&"N/A".to_string())
        );
    }

    Ok(())
}

pub async fn run(self) -> Result<RunOutput, RunError>

Executes the chain.

Examples found in repository

examples/advanced_chain_example.rs (line 79)

async fn run_chain(
    store: &PromptStore,
    registry: &LLMRegistry,
    feedback: &str,
) -> Result<RunOutput, RunError> {
    store
        .chain(registry)
        // Step 1: Always run sentiment analysis.
        .step("sentiment", "Sentiment Check")
            .with_provider("openai")
        // Step 2 (Conditional): Only run if the sentiment is "positive".
        .step_if("positive_reply", "Positive Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("positive"))
        })
            .with_provider("openai")

        // Step 3 (Conditional): Only run if the sentiment is "negative".
        .step_if("negative_reply", "Negative Reply", |prev_outputs| {
            matches!(prev_outputs.get("sentiment"), Some(s) if s.trim().eq_ignore_ascii_case("negative"))
        })
            .with_provider("openai")

        .vars([("feedback", feedback)])
        .run()
        .await
}

examples/parallel_example.rs (line 58)

async fn main() -> Result<(), RunError> {
    let store = PromptStore::init()?;

    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai", openai_llm);

    let user_query = "Rust is a systems programming language focused on safety, speed, and concurrency. It achieves these goals without a garbage collector, using a unique ownership model with a borrow checker.";

    println!("--- Running Advanced Chain ---");

    let outputs = store
        .chain(&registry)
        // 1. First step runs sequentially
        .step("topic", "Extract Topic")
        .with_provider("openai")
        // 2. These two steps run in parallel, as they only depend on the previous context
        .parallel(|group| {
            group
                .step("summary", "Summarizer")
                // This step will fail because the provider doesn't exist
                .step("keywords", "Keyword Extractor")
                .with_provider("failing_provider")
        })
        .with_provider("openai") // Default provider for the group
        // 3. This is a fallback for the "keywords" step. It runs only if the main step fails.
        .on_error_stored("Basic Keyword Extractor")
        .with_provider("openai")
        // 4. This step runs only if the summary contains the word "safety"
        .step_if("tweet", "Generate Tweet", |ctx| {
            ctx.get("summary")
                .map_or(false, |s| s.to_lowercase().contains("safety"))
        })
        .with_provider("openai")
        .vars([("query", user_query)])
        .run()
        .await?;

    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!("\n[1] Topic: {}", map.get("topic").unwrap_or(&"N/A".into()));
        println!(
            "\n[2a] Summary: {}",
            map.get("summary").unwrap_or(&"N/A".into())
        );
        println!(
            "\n[2b] Keywords (used fallback): {}",
            map.get("keywords").unwrap_or(&"N/A".into())
        );

        if let Some(tweet) = map.get("tweet") {
            println!("\n[3] Conditional Tweet: {}", tweet);
        } else {
            println!("\n[3] Conditional Tweet: SKIPPED (condition not met)");
        }
    }

    Ok(())
}

examples/chain_example.rs (line 74)

async fn main() -> Result<(), RunError> {
    // 1. Initialize the store once. This loads keys and configuration.
    // Or use with_password("password") to use a password to decrypt the vault of the prompts.
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    // 2. Set up the LLM providers and a registry to hold them.
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set"))
        .model("gpt-4o-mini")
        .max_tokens(1000)
        .build()
        .unwrap();

    let anthropic_llm = LLMBuilder::new()
        .backend(LLMBackend::Anthropic)
        .api_key(std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY must be set"))
        .model("claude-3-5-sonnet-20240620")
        .max_tokens(1000)
        .build()
        .unwrap();

    let mut registry = LLMRegistry::new();
    registry.insert("openai_fast", openai_llm);
    registry.insert("anthropic_strong", anthropic_llm);

    // 3. Define and run the chain fluently, loading prompts from the store.
    let user_question = "How does photosynthesis work at the molecular level?";

    println!("Executing prompt chain for: \"{}\"", user_question);

    let outputs = store
        .chain(&registry) // Start a chain with the provider registry.
        // Step 1: uses the prompt with id "9k6zezem".
        // Its output will be available as the `{{analyse}}` variable.
        .step("analyse", "9k6zezem")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("openai_fast")
        // Step 2: uses the prompt with id "uetgwnq1".
        // It implicitly uses the `{{analyse}}` output from the previous step.
        .step("suggestions", "uetgwnq1")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Step 3: uses the prompt with id "dkeodfyp".
        // It can use both the initial `{{query}}` and `{{suggestions}}`.
        .step("final_response", "dkeodfyp")
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        .step_raw(
            "raw",
            "Synthesize the following: {{final_response}} in 2 sentences.",
        )
        .with_mode(MultiChainStepMode::Chat)
        .with_provider("anthropic_strong")
        // Provide the initial variable for the first step.
        .vars([("query", user_question)])
        .run()
        .await?;

    // 4. Process the results.
    if let RunOutput::Chain(map) = outputs {
        println!("\n--- Chain Execution Complete ---");
        println!(
            "\n[✅] Final Answer (from 'final_response' step):\n{}",
            map.get("final_response").unwrap_or(&"N/A".to_string())
        );
        println!("\n--- Intermediate Steps ---");
        println!(
            "\n[1] Analysis ('analyse'):\n{}",
            map.get("analyse").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[2] Suggestions ('suggestions'):\n{}",
            map.get("suggestions").unwrap_or(&"N/A".to_string())
        );
        println!(
            "\n[3] Raw ('raw'):\n{}",
            map.get("raw").unwrap_or(&"N/A".to_string())
        );
    }

    Ok(())
}