Struct PromptStore 

pub struct PromptStore { /* private fields */ }

The main entry point for interacting with the prompt store.

This structure is designed to be created once and shared throughout your application. It holds the necessary context, including the encryption cipher.

Implementations

impl PromptStore

pub fn init() -> Result<Self, StoreError>

Initializes the PromptStore by prompting for a password if the key is encrypted.

This function will locate ~/.prompt-store, load the encryption key, and interactively prompt for a password if required.

Examples found in repository

examples/simple_example.rs (line 26)

async fn main() {
    // Get the OpenAI API key from environment variables
    let api_key = std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set");

    // Configure the OpenAI LLM backend
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(api_key)
        .model("gpt-4o")
        .build()
        .unwrap();

    // Initialize the prompt store
    let store = PromptStore::init().unwrap();

    // Execute a prompt with variables and get the result
    let result = store
        .prompt("prompt-store-example::nin5pgu6")
        .vars([("name", "Alice")])
        .backend(openai_llm.as_ref())
        .run()
        .await
        .expect("Prompt execution failed");

    println!("Result: {:?}", result);
}

examples/parallel_example.rs (line 18)

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 with_password(password: &str) -> Result<Self, StoreError>

Initializes the PromptStore non-interactively with a password.

This is useful for server environments where interactive prompts are not possible. The password can be provided from an environment variable or a secret manager.

Arguments

• password - The password to decrypt the master key.

Examples found in repository

examples/advanced_chain_example.rs (line 19)

async fn main() -> Result<(), RunError> {
    let password = std::env::var("PROMPT_STORE_PASSWORD")
        .expect("PROMPT_STORE_PASSWORD must be set for this example.");
    let store = PromptStore::with_password(&password)?;

    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);

    // --- Test with negative feedback ---
    println!("--- Testing with NEGATIVE feedback ---");
    let user_feedback_negative = "The app keeps crashing, it's unusable!";
    let outputs_neg = run_chain(&store, &registry, user_feedback_negative).await?;
    if let RunOutput::Chain(map) = outputs_neg {
        // We expect `negative_reply` to exist, but `positive_reply` should not.
        assert!(map.contains_key("negative_reply"));
        assert!(!map.contains_key("positive_reply"));
        println!("\nFinal Response:\n{}", map.get("negative_reply").unwrap());
    }

    // --- Test with positive feedback ---
    println!("\n--- Testing with POSITIVE feedback ---");
    let user_feedback_positive = "I love the new update, it's so fast!";
    let outputs_pos = run_chain(&store, &registry, user_feedback_positive).await?;
    if let RunOutput::Chain(map) = outputs_pos {
        // We expect `positive_reply` to exist, but `negative_reply` should not.
        assert!(map.contains_key("positive_reply"));
        assert!(!map.contains_key("negative_reply"));
        println!("\nFinal Response:\n{}", map.get("positive_reply").unwrap());
    }

    Ok(())
}

examples/chain_example.rs (line 21)

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 prompt<'a>(&'a self, id_or_title: &'a str) -> PromptRunner<'a>

Creates a runner for executing a single prompt.

Arguments

• id_or_title - The ID or exact title of the prompt to run.

Examples found in repository

examples/simple_example.rs (line 30)

async fn main() {
    // Get the OpenAI API key from environment variables
    let api_key = std::env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY must be set");

    // Configure the OpenAI LLM backend
    let openai_llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(api_key)
        .model("gpt-4o")
        .build()
        .unwrap();

    // Initialize the prompt store
    let store = PromptStore::init().unwrap();

    // Execute a prompt with variables and get the result
    let result = store
        .prompt("prompt-store-example::nin5pgu6")
        .vars([("name", "Alice")])
        .backend(openai_llm.as_ref())
        .run()
        .await
        .expect("Prompt execution failed");

    println!("Result: {:?}", result);
}

pub fn chain<'a, B: Into<LLMBackendRef<'a>>>( &'a self, backend: B, ) -> ChainRunner<'a>

Creates a runner to define and execute a chain of prompts.

Arguments

• backend - The LLM backend to use for the chain. This must be a type that can be converted into LLMBackendRef, typically a &LLMRegistry.

Examples found in repository

examples/advanced_chain_example.rs (line 62)

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 35)

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 50)

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(())
}