Struct NERExtractor 

pub struct NERExtractor { /* private fields */ }

NER extractor with fallback support.

This is the recommended way to use NER in anno. It handles:

• Backend selection based on available features
• Graceful fallback when ML models fail
• Hybrid mode combining ML and patterns

Example

use anno::backends::extractor::NERExtractor;

// Automatic selection (best available)
let extractor = NERExtractor::best_available();

// Explicit backend
let extractor = NERExtractor::with_bert_onnx("protectai/bert-base-NER-onnx")?;

// Extract entities
let entities = extractor.extract("Apple announced new iPhone in Cupertino.", None)?;

Implementations

impl NERExtractor

pub fn new(primary: Option<Arc<dyn Model>>, backend_type: BackendType) -> Self

Create with explicit primary and fallback.

pub fn pattern_only() -> Self

Create with regex-based backend only.

Limited to structured entities: DATE, TIME, MONEY, PERCENT, EMAIL, URL, PHONE

pub fn best_available() -> Self

Create the best available NER extractor.

Tries backends in priority order:

1. GLiNER (if onnx feature enabled) - zero-shot
2. BERT ONNX (if onnx feature enabled) - reliable fixed-type NER
3. Candle (if candle feature enabled) - Rust-native inference
4. RegexNER (always) - structured entities only

pub fn fast() -> Self

Create the fastest available NER extractor.

Prioritizes speed over accuracy:

1. GLiNER small (if onnx feature) - fast zero-shot
2. RegexNER (always)

pub fn best_quality() -> Self

Create the highest quality NER extractor.

Prioritizes accuracy over speed:

1. GLiNER large (if onnx feature) - highest accuracy
2. GLiNER medium (if onnx feature) - fallback
3. BERT ONNX (if onnx feature) - reliable
4. RegexNER (always)

pub fn with_bert_onnx(model_name: &str) -> Result<Self>

Create with BERT ONNX backend.

Uses standard BERT models fine-tuned for NER with BIO tagging. Reliable and widely tested, but limited to fixed entity types.

Arguments

• model_name - HuggingFace model identifier (e.g., “protectai/bert-base-NER-onnx”)

pub fn with_gliner(model_name: &str) -> Result<Self>

Create with GLiNER backend (zero-shot NER).

GLiNER is the recommended backend for best accuracy on named entities. It supports zero-shot NER (any entity type without retraining).

Arguments

• model_name - HuggingFace model identifier (e.g., “onnx-community/gliner_small-v2.1”)

pub fn with_candle(_model_name: &str) -> Result<Self>

Stub for when candle feature is disabled.

pub fn extract(&self, text: &str, language: Option<&str>) -> Result<Vec<Entity>>

Extract entities with automatic fallback.

Tries primary ML backend first, falls back to patterns if it fails.

pub fn extract_hybrid( &self, text: &str, language: Option<&str>, ) -> Result<Vec<Entity>>

Extract entities using hybrid strategy.

Combines ML model (for semantic entities) with patterns (for structured entities):

• ML: Person, Organization, Location (context-dependent)
• Patterns: Date, Money, Percent, Email, URL, Phone (format-based)

This gets best of both worlds:

• High F1 on ambiguous entities (via ML)
• 100% precision on pattern entities (via patterns)

pub fn backend_type(&self) -> BackendType

Get the active backend type.

pub fn active_backend_name(&self) -> &'static str

Get the name of the active backend.

pub fn has_ml_backend(&self) -> bool

Check if ML backend is available.

pub fn supports_zero_shot(&self) -> bool

Check if this extractor supports zero-shot NER.

Trait Implementations

impl Model for NERExtractor

fn extract_entities( &self, text: &str, language: Option<&str>, ) -> Result<Vec<Entity>>

Extract entities from text.

fn supported_types(&self) -> Vec<EntityType>

Get supported entity types.

fn is_available(&self) -> bool

Check if model is available and ready.

fn name(&self) -> &'static str

Get the model name/identifier.

fn description(&self) -> &'static str

Get a description of the model.

fn capabilities(&self) -> ModelCapabilities

Get capability summary for this model.

fn version(&self) -> String

Get a version identifier for the model configuration/weights.