pub fn create_embedder(model_name: Option<&str>) -> Result<Box<dyn Embedder>>Examples found in repository?
examples/test_nomic.rs (line 22)
17fn run_example() {
18 println!("=== Testing Nomic Model ===");
19
20 println!("Attempting to create Nomic Embed Text V1.5 embedder...");
21
22 let result = create_embedder(Some("nomic-embed-text-v1.5"));
23
24 match result {
25 Ok(mut embedder) => {
26 println!("✅ Successfully created embedder: {}", embedder.id());
27 println!(" Dimensions: {}", embedder.dim());
28
29 let test_texts = vec!["hello world".to_string()];
30 println!("Testing embedding generation...");
31
32 match embedder.embed(&test_texts) {
33 Ok(embeddings) => {
34 println!("✅ Successfully generated embeddings");
35 println!(
36 " Shape: {} embeddings of {} dimensions",
37 embeddings.len(),
38 embeddings[0].len()
39 );
40 }
41 Err(e) => {
42 println!("❌ Failed to generate embeddings: {}", e);
43 }
44 }
45 }
46 Err(e) => {
47 println!("❌ Failed to create Nomic embedder: {}", e);
48 println!(" Error details: {:?}", e);
49
50 println!("\n--- Trying alternative model names ---");
51
52 // Try different variations
53 let alternatives = [
54 "nomic-embed-text-v1",
55 "NomicEmbedTextV15",
56 "NomicEmbedTextV1",
57 ];
58
59 for alt in alternatives {
60 println!("Trying: {}", alt);
61 match create_embedder(Some(alt)) {
62 Ok(_) => println!(" ✅ {} works!", alt),
63 Err(e) => println!(" ❌ {} failed: {}", alt, e),
64 }
65 }
66 }
67 }
68
69 println!("\n--- Testing working BGE model for comparison ---");
70 match create_embedder(Some("BAAI/bge-small-en-v1.5")) {
71 Ok(embedder) => println!("✅ BGE model works: {} dims", embedder.dim()),
72 Err(e) => println!("❌ Even BGE failed: {}", e),
73 }
74}More examples
examples/test_mixedbread.rs (line 47)
21fn run_example() {
22 println!("=== Testing Mixedbread Models ===\n");
23
24 // Test 1: Model Registry Resolution
25 println!("1. Testing Model Registry Resolution");
26 println!(" Checking if 'mxbai-xsmall' alias resolves...");
27
28 let registry = ModelRegistry::default();
29 match registry.resolve(Some("mxbai-xsmall")) {
30 Ok((alias, config)) => {
31 println!(" ✅ Resolved alias: '{}'", alias);
32 println!(" Model name: {}", config.name);
33 println!(" Provider: {}", config.provider);
34 println!(" Dimensions: {}", config.dimensions);
35 println!(" Max tokens: {}", config.max_tokens);
36 }
37 Err(e) => {
38 println!(" ❌ Failed to resolve alias: {}", e);
39 return;
40 }
41 }
42
43 // Test 2: Embedder Creation
44 println!("\n2. Testing Mixedbread Embedder Creation");
45 println!(" Attempting to create Mixedbread embedder...");
46
47 let result = create_embedder(Some("mixedbread-ai/mxbai-embed-xsmall-v1"));
48
49 match result {
50 Ok(mut embedder) => {
51 println!(" ✅ Successfully created embedder: {}", embedder.id());
52 println!(" Model name: {}", embedder.model_name());
53 println!(" Dimensions: {}", embedder.dim());
54
55 // Test 3: Embedding Generation
56 println!("\n3. Testing Embedding Generation");
57 let test_texts = vec![
58 "Hello world".to_string(),
59 "Rust programming language".to_string(),
60 "Machine learning and artificial intelligence".to_string(),
61 ];
62 println!(" Generating embeddings for {} texts...", test_texts.len());
63
64 match embedder.embed(&test_texts) {
65 Ok(embeddings) => {
66 println!(" ✅ Successfully generated embeddings");
67 println!(
68 " Shape: {} embeddings of {} dimensions",
69 embeddings.len(),
70 embeddings[0].len()
71 );
72
73 // Verify dimensions
74 assert_eq!(
75 embeddings.len(),
76 test_texts.len(),
77 "Should have one embedding per text"
78 );
79 assert_eq!(
80 embeddings[0].len(),
81 384,
82 "Mixedbread xsmall should produce 384-dim vectors"
83 );
84
85 // Check normalization (L2 norm should be ~1.0)
86 for (i, emb) in embeddings.iter().enumerate() {
87 let norm: f32 = emb.iter().map(|x| x * x).sum::<f32>().sqrt();
88 println!(
89 " Embedding {} L2 norm: {:.6} (should be ~1.0)",
90 i, norm
91 );
92 assert!(
93 (norm - 1.0).abs() < 0.01,
94 "Embeddings should be L2-normalized"
95 );
96 }
97 }
98 Err(e) => {
99 println!(" ❌ Failed to generate embeddings: {}", e);
100 return;
101 }
102 }
103 }
104 Err(e) => {
105 println!(" ❌ Failed to create Mixedbread embedder: {}", e);
106 println!(" Error details: {:?}", e);
107 return;
108 }
109 }
110
111 // Test 4: Reranker Registry Resolution
112 println!("\n4. Testing Reranker Registry Resolution");
113 println!(" Checking if 'mxbai' reranker alias resolves...");
114
115 let rerank_registry = RerankModelRegistry::default();
116 match rerank_registry.resolve(Some("mxbai")) {
117 Ok((alias, config)) => {
118 println!(" ✅ Resolved reranker alias: '{}'", alias);
119 println!(" Model name: {}", config.name);
120 println!(" Provider: {}", config.provider);
121 }
122 Err(e) => {
123 println!(" ❌ Failed to resolve reranker alias: {}", e);
124 return;
125 }
126 }
127
128 // Test 5: Reranker Creation
129 println!("\n5. Testing Mixedbread Reranker Creation");
130 println!(" Attempting to create Mixedbread reranker...");
131
132 match create_reranker(Some("mixedbread-ai/mxbai-rerank-xsmall-v1")) {
133 Ok(mut reranker) => {
134 println!(" ✅ Successfully created reranker: {}", reranker.id());
135
136 // Test 6: Reranking
137 println!("\n6. Testing Reranking");
138 let query = "error handling in Rust";
139 let documents = vec![
140 "Rust error handling with Result and Option types".to_string(),
141 "Python web development frameworks".to_string(),
142 "Rust provides excellent error handling mechanisms".to_string(),
143 "JavaScript async programming patterns".to_string(),
144 ];
145 println!(" Query: '{}'", query);
146 println!(" Reranking {} documents...", documents.len());
147
148 match reranker.rerank(query, &documents) {
149 Ok(results) => {
150 println!(" ✅ Successfully reranked documents");
151 println!(" Results (sorted by score):");
152 for (i, result) in results.iter().enumerate() {
153 println!(
154 " {}. Score: {:.4} | Doc: {}",
155 i + 1,
156 result.score,
157 if result.document.len() > 60 {
158 &result.document[..60]
159 } else {
160 &result.document
161 }
162 );
163 }
164
165 // Verify results are sorted by score (descending)
166 let scores: Vec<f32> = results.iter().map(|r| r.score).collect();
167 let sorted_scores: Vec<f32> = {
168 let mut s = scores.clone();
169 s.sort_by(|a, b| b.partial_cmp(a).unwrap());
170 s
171 };
172 assert_eq!(
173 scores, sorted_scores,
174 "Results should be sorted by score descending"
175 );
176
177 // Verify scores are in valid range [0, 1]
178 for result in &results {
179 assert!(
180 result.score >= 0.0 && result.score <= 1.0,
181 "Rerank scores should be in [0, 1] range"
182 );
183 }
184 }
185 Err(e) => {
186 println!(" ❌ Failed to rerank: {}", e);
187 return;
188 }
189 }
190 }
191 Err(e) => {
192 println!(" ❌ Failed to create Mixedbread reranker: {}", e);
193 println!(" Error details: {:?}", e);
194 return;
195 }
196 }
197
198 println!("\n=== All Tests Passed! ===");
199}