post-cortex-embeddings 0.3.1

Embedding engines (Model2Vec static + BERT via Candle + static-hash fallback) and HNSW vector database for post-cortex. Self-contained ML stack — depend on this crate when you need vector search without the full post-cortex orchestrator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Copyright (c) 2025 Julius ML
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

//! Pluggable embedding backend trait.
//!
//! [`LocalEmbeddingEngine`](super::engine::LocalEmbeddingEngine) wraps any
//! `EmbeddingBackend` and adds adaptive batching, concurrency control, timeouts,
//! and performance tracking around the backend's raw `process_batch` call.
//!
//! Drop-in replacements (e.g. `model2vec-rs` static embeddings) implement this
//! trait and become available to all callers without touching the engine.

use anyhow::Result;
use async_trait::async_trait;

/// A backend capable of producing embedding vectors for a batch of texts.
#[async_trait]
pub trait EmbeddingBackend: Send + Sync {
    /// Dimension of the produced embedding vectors.
    fn embedding_dimension(&self) -> usize;

    /// Whether this backend runs a BERT-style model. BERT backends are routed
    /// through the engine's concurrency controller, timeout, and adaptive
    /// batching machinery; non-BERT backends are invoked directly.
    fn is_bert_based(&self) -> bool;

    /// Process a batch of texts and return one embedding vector per text.
    /// The engine slices large inputs into chunks no larger than the engine's
    /// `current_batch_size` before calling this method.
    async fn process_batch(&self, texts: Vec<String>) -> Result<Vec<Vec<f32>>>;
}