Struct MemexEngine 

pub struct MemexEngine { /* private fields */ }

High-level API for vector memory operations.

MemexEngine provides a simple interface for storing, searching, and managing vector embeddings. It orchestrates the embedding client and storage manager.

Implementations

impl MemexEngine

pub async fn new(config: MemexConfig) -> Result<Self>

Create a new MemexEngine with the given configuration.

Example

let config = MemexConfig::new("my-app", "documents")
    .with_dimension(1024);
let engine = MemexEngine::new(config).await?;

pub async fn for_app(app_name: &str, namespace: &str) -> Result<Self>

Quick setup for an application.

Uses default embedding configuration and auto-detects providers.

Example

let engine = MemexEngine::for_app("vista", "patient-notes").await?;

pub async fn for_vista() -> Result<Self>

Vista-optimized setup with 1024-dimension embeddings.

Uses smaller embedding model (qwen3-embedding:0.6b) for faster inference.

Example

let engine = MemexEngine::for_vista().await?;

pub fn namespace(&self) -> &str

Get the namespace this engine operates on

pub fn config(&self) -> &MemexConfig

Get the configuration

pub fn storage(&self) -> Arc<StorageManager>

Get the underlying storage manager (for advanced operations)

pub async fn store(&self, id: &str, text: &str, metadata: Value) -> Result<()>

Store a document with embedding.

The text is automatically embedded using the configured embedding provider.

Arguments

• id - Unique document identifier
• text - Text content to embed and store
• metadata - Additional metadata (JSON object)

Example

engine.store(
    "visit-123",
    "Patient presented with lethargy and decreased appetite...",
    json!({"patient_id": "P-456", "visit_type": "checkup"})
).await?;

pub async fn search( &self, query: &str, limit: usize, ) -> Result<Vec<SearchResult>>

Search for similar documents.

Returns documents ordered by similarity score (highest first).

Arguments

• query - Search query text
• limit - Maximum number of results

Example

let results = engine.search("lethargy symptoms", 10).await?;
for result in results {
    println!("{}: {} (score: {})", result.id, result.text, result.score);
}

pub async fn search_hybrid( &self, query: &str, limit: usize, ) -> Result<Vec<HybridSearchResult>>

Hybrid search combining vector similarity and BM25 keyword matching.

Returns results with combined scores from both methods. Requires enable_hybrid: true in config.

Example

let results = engine.search_hybrid("when did we buy dragon", 10).await?;
for r in results {
    println!("{}: combined={:.3}, vector={:?}, bm25={:?}",
        r.id, r.combined_score, r.vector_score, r.bm25_score);
}

pub async fn search_with_mode( &self, query: &str, limit: usize, mode: SearchMode, ) -> Result<Vec<HybridSearchResult>>

Search with explicit mode selection.

Allows choosing between vector-only, keyword-only, or hybrid search.

Example

use rust_memex::SearchMode;

// Keyword-only for exact matches
let results = engine.search_with_mode("dragon", 10, SearchMode::Keyword).await?;

pub async fn get(&self, id: &str) -> Result<Option<SearchResult>>

Get a document by ID.

Example

if let Some(doc) = engine.get("visit-123").await? {
    println!("Found: {}", doc.text);
}

pub async fn delete(&self, id: &str) -> Result<bool>

Delete a document by ID.

Returns true if a document was deleted, false if not found.

Example

if engine.delete("visit-123").await? {
    println!("Document deleted");
}

pub async fn store_batch(&self, items: Vec<StoreItem>) -> Result<BatchResult>

Store multiple documents in a batch.

More efficient than calling store() multiple times as embeddings are generated in batches.

Example

let items = vec![
    StoreItem::new("doc-1", "First document").with_metadata(json!({"type": "note"})),
    StoreItem::new("doc-2", "Second document").with_metadata(json!({"type": "note"})),
];
let result = engine.store_batch(items).await?;
println!("Stored {} documents", result.success_count);

pub async fn search_filtered( &self, query: &str, filter: MetaFilter, limit: usize, ) -> Result<Vec<SearchResult>>

Search with metadata filter.

Performs vector search and then filters results by metadata.

Example

let filter = MetaFilter::for_patient("P-456");
let results = engine.search_filtered("symptoms", filter, 10).await?;

pub async fn delete_by_filter(&self, filter: MetaFilter) -> Result<usize>

Delete all documents matching a filter.

This is the primary method for GDPR-compliant data deletion.

Example

// Delete all documents for a patient (GDPR request)
let filter = MetaFilter::for_patient("P-456");
let deleted = engine.delete_by_filter(filter).await?;
println!("Deleted {} documents", deleted);

pub async fn purge_namespace(&self) -> Result<usize>

Delete all documents in the namespace.

Use with caution - this removes all data!

pub async fn search_bm25_fusion( &self, query: &str, limit: usize, bm25_weight: f32, ) -> Result<Vec<SearchResult>>

👎Deprecated since 0.3.1:

Use search_hybrid() with HybridSearcher instead

Hybrid search combining BM25 keyword matching with vector similarity.

Requires enable_bm25: true in config.

Arguments

• query - Search query
• limit - Maximum results
• bm25_weight - Weight for BM25 scores (0.0-1.0, default 0.3)