Struct ContextForgeBuilder 

pub struct ContextForgeBuilder { /* private fields */ }

Builder for ContextForge.

Lexicon scoring is opt-in. By default the engine ranks on relevance (BM25, plus semantic when an embedding model is set) with no lexicon layer. Lexicon scoring applies a query-independent importance boost, which suits persona/importance use cases but degrades pure relevance retrieval — so it must be requested explicitly:

• with_default_english_scorer enables the built-in DefaultEnglishScorer (plain-English commitment/ confirmation/decision markers).
• with_persona_scorer adds a domain scorer.

When both are set they compose additively via CompositeLexiconScorer.

Example

use context_forge::{Config, ContextForge, ConfigLexiconScorer};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), context_forge::Error> {
    let mut config = Config::default();
    config.db_path = PathBuf::from("memory.db");

    // Relevance only, no lexicon (default):
    let cf = ContextForge::builder(config.clone()).build().await?;

    // Opt into the English importance scorer:
    let cf = ContextForge::builder(config.clone())
        .with_default_english_scorer()
        .build()
        .await?;

    // English + a persona scorer loaded from a TOML string:
    let toml = "[affirmations]\npatterns = [\"for the emperor\"]";
    let persona: ConfigLexiconScorer = toml.parse()?;
    let cf = ContextForge::builder(config)
        .with_default_english_scorer()
        .with_persona_scorer(persona)
        .build()
        .await?;

    Ok(())
}

Implementations

impl ContextForgeBuilder

pub fn new(config: Config) -> Self

Create a new builder with the given config.

Prefer ContextForge::builder over calling this directly.

pub fn with_default_english_scorer(self) -> Self

Enable the built-in DefaultEnglishScorer (opt-in).

Applies a query-independent importance boost to entries containing plain-English commitment/confirmation/decision/correction markers (“i’ll fix it”, “confirmed”, “we decided”, “never mind”). This is the right signal for persona/importance use cases (surfacing what matters to a user) but hurts pure relevance retrieval — a factual-QA benchmark showed it lowering recall by burying evidence under important-sounding distractors. Off by default for that reason; enable it when importance, not just relevance, is what you want to rank on.

pub fn with_persona_scorer(self, scorer: impl LexiconScorer + 'static) -> Self

Add a persona scorer (opt-in).

Typically a crate::ConfigLexiconScorer loaded from a domain-specific TOML file. If with_default_english_scorer was also called, the two compose additively via CompositeLexiconScorer and the engine applies a -1.0 floor after fusion; otherwise the persona scorer is used alone.

pub async fn build(self) -> Result<ContextForge>

Open the database and build a ContextForge with the configured scorers.

Lexicon scoring is applied only if with_default_english_scorer and/or with_persona_scorer were called; with both, they compose via CompositeLexiconScorer. With neither, the engine ranks on relevance (BM25 + semantic) only.

Errors

Returns an error if the database cannot be opened or migrations fail.