laurus

Core search engine library for the Laurus project. Provides lexical search (keyword matching via inverted index), vector search (semantic similarity via embeddings), and hybrid search (combining both) through a unified API.

Features

• Lexical Search -- Full-text search powered by an inverted index with BM25 scoring
• Vector Search -- Approximate nearest neighbor (ANN) search using Flat, HNSW, or IVF indexes
• Hybrid Search -- Combine lexical and vector results with fusion algorithms (RRF, WeightedSum)
• Text Analysis -- Pluggable analyzer pipeline: tokenizers, filters, stemmers, synonyms (including CJK support via Lindera)
• Embeddings -- Built-in support for Candle (local BERT/CLIP), OpenAI API, or custom embedders
• Pluggable Storage -- In-memory, file-based, or memory-mapped backends
• Faceting & Highlighting -- Faceted navigation and search result highlighting
• Spelling Correction -- Suggest corrections for misspelled query terms
• Write-Ahead Log -- Durability via WAL with automatic recovery on restart

Installation

# Lexical search only (no embedding)
[dependencies]
laurus = "0.2"

# With local BERT embeddings
[dependencies]
laurus = { version = "0.2", features = ["embeddings-candle"] }

# All embedding backends
[dependencies]
laurus = { version = "0.2", features = ["embeddings-all"] }

Feature Flags

Quick Start

use laurus::lexical::{TermQuery, TextOption};
use laurus::storage::memory::MemoryStorageConfig;
use laurus::storage::{StorageConfig, StorageFactory};
use laurus::{Document, Engine, LexicalSearchRequest, Schema, SearchRequestBuilder};

#[tokio::main]
async fn main() -> laurus::Result<()> {
    // 1. Create storage
    let storage = StorageFactory::create(StorageConfig::Memory(MemoryStorageConfig::default()))?;

    // 2. Define schema
    let schema = Schema::builder()
        .add_text_field("title", TextOption::default())
        .add_text_field("body", TextOption::default())
        .build();

    // 3. Create engine
    let engine = Engine::new(storage, schema).await?;

    // 4. Index documents
    engine
        .add_document(
            "doc1",
            Document::builder()
                .add_text("title", "Introduction to Rust")
                .add_text(
                    "body",
                    "Rust is a systems programming language focused on safety and performance.",
                )
                .build(),
        )
        .await?;
    engine.commit().await?;

    // 5. Search
    let results = engine
        .search(
            SearchRequestBuilder::new()
                .lexical_search_request(LexicalSearchRequest::new(Box::new(TermQuery::new(
                    "body", "rust",
                ))))
                .limit(5)
                .build(),
        )
        .await?;

    for hit in &results {
        println!("[{}] score={:.4}", hit.id, hit.score);
    }

    Ok(())
}

Key Types

Examples

Usage examples are in the examples/ directory:

Documentation

• Library Guide
• API Reference (docs.rs)
• Architecture
• Schema & Fields
• Text Analysis
• Search

License

This project is licensed under the MIT License - see the LICENSE file for details.