Struct GenerationEngine 

pub struct GenerationEngine { /* private fields */ }

Text generation engine using GGUF models.

Implementations

impl GenerationEngine

pub fn new(model_path: &Path) -> Result<Self>

Create a new generation engine with the specified model.

pub fn load_default() -> Result<Self>

Load the default generation model.

Examples found in repository

examples/query_expansion.rs (line 52)

fn main() -> Result<()> {
    let db_path = std::env::temp_dir().join("qmd_expansion.db");
    let _ = std::fs::remove_file(&db_path);
    let store = Store::open(&db_path)?;

    let now = chrono::Utc::now().to_rfc3339();
    for (name, content) in SAMPLE_DOCS {
        let hash = Store::hash_content(content);
        let title = Store::extract_title(content);
        store.insert_content(&hash, content, &now)?;
        store.insert_document("samples", name, &title, &hash, &now, &now)?;
    }

    let query = "rust error handling";
    println!("Query: '{}'\n", query);

    // Simple expansion
    println!("Simple expansion:");
    for q in expand_query_simple(query) {
        let t = match q.query_type {
            QueryType::Lex => "LEX",
            QueryType::Vec => "VEC",
            QueryType::Hyde => "HYD",
        };
        println!("  [{}] {}", t, q.text);
    }

    // Search with expanded queries
    println!("\nSearch results:");
    for q in expand_query_simple(query) {
        if q.query_type == QueryType::Lex {
            let n = store.search_fts(&q.text, 5, None)?.len();
            println!("  '{}': {} results", q.text, n);
        }
    }

    // LLM expansion
    println!("\nLLM expansion:");
    if GenerationEngine::is_available() {
        let engine = GenerationEngine::load_default()?;
        for q in engine.expand_query(query, true)? {
            println!("  [{:?}] {}", q.query_type, q.text);
        }
    } else {
        println!("  (not available)");
    }

    // Manual construction
    println!("\nManual:");
    for q in [
        Queryable::lex("rust error"),
        Queryable::vec("exception handling"),
    ] {
        println!("  [{:?}] {}", q.query_type, q.text);
    }

    let _ = std::fs::remove_file(&db_path);
    Ok(())
}

pub fn is_available() -> bool

Check if generation model exists.

Examples found in repository

examples/models.rs (line 33)

fn main() -> Result<()> {
    // Cache directory
    println!("Cache: {}\n", get_model_cache_dir().display());

    // Cached models
    println!("Cached models:");
    let models = list_cached_models();
    if models.is_empty() {
        println!("  (none - will download)");
    } else {
        for m in &models {
            println!("  {}", m);
        }
    }

    // Model availability check
    println!("\nAvailability:");
    let check = |name: &str, ok: bool| println!("  {}: {}", name, if ok { "yes" } else { "no" });
    check("embed model", model_exists(DEFAULT_EMBED_MODEL));
    check("EmbeddingEngine", EmbeddingEngine::load_default().is_ok());
    check("GenerationEngine", GenerationEngine::is_available());
    check("RerankEngine", RerankEngine::is_available());

    // Download model (demo)
    println!("\nDownloading embedding model...");
    let result = pull_model(DEFAULT_EMBED_MODEL_URI, false)?;
    println!("  Path: {}", result.path.display());
    println!("  Size: {} bytes", result.size_bytes);
    println!("  Refreshed: {}", result.refreshed);

    // URI resolution
    println!("\nURI resolution:");
    let uri = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
    if let Ok(path) = resolve_model(uri) {
        println!("  {} ->\n  {}", uri, path.display());
    }

    // Load and test
    let mut engine = EmbeddingEngine::new(&result.path)?;
    let emb = engine.embed("test embedding")?;
    println!("\nModel info:");
    println!("  Name: {}", emb.model);
    println!("  Dimensions: {}", emb.embedding.len());

    Ok(())
}

examples/query_expansion.rs (line 51)

fn main() -> Result<()> {
    let db_path = std::env::temp_dir().join("qmd_expansion.db");
    let _ = std::fs::remove_file(&db_path);
    let store = Store::open(&db_path)?;

    let now = chrono::Utc::now().to_rfc3339();
    for (name, content) in SAMPLE_DOCS {
        let hash = Store::hash_content(content);
        let title = Store::extract_title(content);
        store.insert_content(&hash, content, &now)?;
        store.insert_document("samples", name, &title, &hash, &now, &now)?;
    }

    let query = "rust error handling";
    println!("Query: '{}'\n", query);

    // Simple expansion
    println!("Simple expansion:");
    for q in expand_query_simple(query) {
        let t = match q.query_type {
            QueryType::Lex => "LEX",
            QueryType::Vec => "VEC",
            QueryType::Hyde => "HYD",
        };
        println!("  [{}] {}", t, q.text);
    }

    // Search with expanded queries
    println!("\nSearch results:");
    for q in expand_query_simple(query) {
        if q.query_type == QueryType::Lex {
            let n = store.search_fts(&q.text, 5, None)?.len();
            println!("  '{}': {} results", q.text, n);
        }
    }

    // LLM expansion
    println!("\nLLM expansion:");
    if GenerationEngine::is_available() {
        let engine = GenerationEngine::load_default()?;
        for q in engine.expand_query(query, true)? {
            println!("  [{:?}] {}", q.query_type, q.text);
        }
    } else {
        println!("  (not available)");
    }

    // Manual construction
    println!("\nManual:");
    for q in [
        Queryable::lex("rust error"),
        Queryable::vec("exception handling"),
    ] {
        println!("  [{:?}] {}", q.query_type, q.text);
    }

    let _ = std::fs::remove_file(&db_path);
    Ok(())
}

pub fn generate( &self, prompt: &str, max_tokens: usize, ) -> Result<GenerationResult>

Generate text from a prompt using simple token-by-token generation.

pub fn expand_query( &self, query: &str, include_lexical: bool, ) -> Result<Vec<Queryable>>

Expand a query into multiple search variations.

Examples found in repository

examples/query_expansion.rs (line 53)

fn main() -> Result<()> {
    let db_path = std::env::temp_dir().join("qmd_expansion.db");
    let _ = std::fs::remove_file(&db_path);
    let store = Store::open(&db_path)?;

    let now = chrono::Utc::now().to_rfc3339();
    for (name, content) in SAMPLE_DOCS {
        let hash = Store::hash_content(content);
        let title = Store::extract_title(content);
        store.insert_content(&hash, content, &now)?;
        store.insert_document("samples", name, &title, &hash, &now, &now)?;
    }

    let query = "rust error handling";
    println!("Query: '{}'\n", query);

    // Simple expansion
    println!("Simple expansion:");
    for q in expand_query_simple(query) {
        let t = match q.query_type {
            QueryType::Lex => "LEX",
            QueryType::Vec => "VEC",
            QueryType::Hyde => "HYD",
        };
        println!("  [{}] {}", t, q.text);
    }

    // Search with expanded queries
    println!("\nSearch results:");
    for q in expand_query_simple(query) {
        if q.query_type == QueryType::Lex {
            let n = store.search_fts(&q.text, 5, None)?.len();
            println!("  '{}': {} results", q.text, n);
        }
    }

    // LLM expansion
    println!("\nLLM expansion:");
    if GenerationEngine::is_available() {
        let engine = GenerationEngine::load_default()?;
        for q in engine.expand_query(query, true)? {
            println!("  [{:?}] {}", q.query_type, q.text);
        }
    } else {
        println!("  (not available)");
    }

    // Manual construction
    println!("\nManual:");
    for q in [
        Queryable::lex("rust error"),
        Queryable::vec("exception handling"),
    ] {
        println!("  [{:?}] {}", q.query_type, q.text);
    }

    let _ = std::fs::remove_file(&db_path);
    Ok(())
}

Trait Implementations

impl Debug for GenerationEngine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.