Skip to main content

vectorizer_protocol/grpc_gen/
vectorizer.rs

1// This file is @generated by prost-build.
2/// Collection management messages
3#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
4pub struct ListCollectionsRequest {}
5#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
6pub struct ListCollectionsResponse {
7    #[prost(string, repeated, tag = "1")]
8    pub collection_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
9}
10#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
11pub struct CreateCollectionRequest {
12    #[prost(string, tag = "1")]
13    pub name: ::prost::alloc::string::String,
14    #[prost(message, optional, tag = "2")]
15    pub config: ::core::option::Option<CollectionConfig>,
16}
17#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
18pub struct CreateCollectionResponse {
19    #[prost(bool, tag = "1")]
20    pub success: bool,
21    #[prost(string, tag = "2")]
22    pub message: ::prost::alloc::string::String,
23}
24#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
25pub struct GetCollectionInfoRequest {
26    #[prost(string, tag = "1")]
27    pub collection_name: ::prost::alloc::string::String,
28}
29#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
30pub struct GetCollectionInfoResponse {
31    #[prost(message, optional, tag = "1")]
32    pub info: ::core::option::Option<CollectionInfo>,
33}
34#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
35pub struct DeleteCollectionRequest {
36    #[prost(string, tag = "1")]
37    pub collection_name: ::prost::alloc::string::String,
38}
39#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
40pub struct DeleteCollectionResponse {
41    #[prost(bool, tag = "1")]
42    pub success: bool,
43    #[prost(string, tag = "2")]
44    pub message: ::prost::alloc::string::String,
45}
46/// Vector operation messages
47#[derive(Clone, PartialEq, ::prost::Message)]
48pub struct InsertVectorRequest {
49    #[prost(string, tag = "1")]
50    pub collection_name: ::prost::alloc::string::String,
51    #[prost(string, tag = "2")]
52    pub vector_id: ::prost::alloc::string::String,
53    #[prost(float, repeated, tag = "3")]
54    pub data: ::prost::alloc::vec::Vec<f32>,
55    #[prost(map = "string, string", tag = "4")]
56    pub payload: ::std::collections::HashMap<
57        ::prost::alloc::string::String,
58        ::prost::alloc::string::String,
59    >,
60}
61#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
62pub struct InsertVectorResponse {
63    #[prost(bool, tag = "1")]
64    pub success: bool,
65    #[prost(string, tag = "2")]
66    pub message: ::prost::alloc::string::String,
67}
68#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
69pub struct InsertVectorsResponse {
70    #[prost(uint32, tag = "1")]
71    pub inserted_count: u32,
72    #[prost(uint32, tag = "2")]
73    pub failed_count: u32,
74    #[prost(string, repeated, tag = "3")]
75    pub errors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
76}
77#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
78pub struct GetVectorRequest {
79    #[prost(string, tag = "1")]
80    pub collection_name: ::prost::alloc::string::String,
81    #[prost(string, tag = "2")]
82    pub vector_id: ::prost::alloc::string::String,
83}
84#[derive(Clone, PartialEq, ::prost::Message)]
85pub struct GetVectorResponse {
86    #[prost(string, tag = "1")]
87    pub vector_id: ::prost::alloc::string::String,
88    #[prost(float, repeated, tag = "2")]
89    pub data: ::prost::alloc::vec::Vec<f32>,
90    #[prost(map = "string, string", tag = "3")]
91    pub payload: ::std::collections::HashMap<
92        ::prost::alloc::string::String,
93        ::prost::alloc::string::String,
94    >,
95}
96#[derive(Clone, PartialEq, ::prost::Message)]
97pub struct UpdateVectorRequest {
98    #[prost(string, tag = "1")]
99    pub collection_name: ::prost::alloc::string::String,
100    #[prost(string, tag = "2")]
101    pub vector_id: ::prost::alloc::string::String,
102    #[prost(float, repeated, tag = "3")]
103    pub data: ::prost::alloc::vec::Vec<f32>,
104    #[prost(map = "string, string", tag = "4")]
105    pub payload: ::std::collections::HashMap<
106        ::prost::alloc::string::String,
107        ::prost::alloc::string::String,
108    >,
109}
110#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
111pub struct UpdateVectorResponse {
112    #[prost(bool, tag = "1")]
113    pub success: bool,
114    #[prost(string, tag = "2")]
115    pub message: ::prost::alloc::string::String,
116}
117#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
118pub struct DeleteVectorRequest {
119    #[prost(string, tag = "1")]
120    pub collection_name: ::prost::alloc::string::String,
121    #[prost(string, tag = "2")]
122    pub vector_id: ::prost::alloc::string::String,
123}
124#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
125pub struct DeleteVectorResponse {
126    #[prost(bool, tag = "1")]
127    pub success: bool,
128    #[prost(string, tag = "2")]
129    pub message: ::prost::alloc::string::String,
130}
131/// Search operation messages
132#[derive(Clone, PartialEq, ::prost::Message)]
133pub struct SearchRequest {
134    #[prost(string, tag = "1")]
135    pub collection_name: ::prost::alloc::string::String,
136    #[prost(float, repeated, tag = "2")]
137    pub query_vector: ::prost::alloc::vec::Vec<f32>,
138    #[prost(uint32, tag = "3")]
139    pub limit: u32,
140    #[prost(double, tag = "4")]
141    pub threshold: f64,
142    #[prost(map = "string, string", tag = "5")]
143    pub filter: ::std::collections::HashMap<
144        ::prost::alloc::string::String,
145        ::prost::alloc::string::String,
146    >,
147}
148#[derive(Clone, PartialEq, ::prost::Message)]
149pub struct SearchResponse {
150    #[prost(message, repeated, tag = "1")]
151    pub results: ::prost::alloc::vec::Vec<SearchResult>,
152}
153#[derive(Clone, PartialEq, ::prost::Message)]
154pub struct BatchSearchRequest {
155    #[prost(string, tag = "1")]
156    pub collection_name: ::prost::alloc::string::String,
157    #[prost(message, repeated, tag = "2")]
158    pub queries: ::prost::alloc::vec::Vec<SearchRequest>,
159}
160#[derive(Clone, PartialEq, ::prost::Message)]
161pub struct BatchSearchResponse {
162    #[prost(message, repeated, tag = "1")]
163    pub results: ::prost::alloc::vec::Vec<SearchResponse>,
164}
165#[derive(Clone, PartialEq, ::prost::Message)]
166pub struct HybridSearchRequest {
167    #[prost(string, tag = "1")]
168    pub collection_name: ::prost::alloc::string::String,
169    #[prost(float, repeated, tag = "2")]
170    pub dense_query: ::prost::alloc::vec::Vec<f32>,
171    #[prost(message, optional, tag = "3")]
172    pub sparse_query: ::core::option::Option<SparseVector>,
173    #[prost(message, optional, tag = "4")]
174    pub config: ::core::option::Option<HybridSearchConfig>,
175}
176#[derive(Clone, PartialEq, ::prost::Message)]
177pub struct HybridSearchResponse {
178    #[prost(message, repeated, tag = "1")]
179    pub results: ::prost::alloc::vec::Vec<HybridSearchResult>,
180}
181/// Health and stats messages
182#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
183pub struct HealthCheckRequest {}
184#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
185pub struct HealthCheckResponse {
186    #[prost(string, tag = "1")]
187    pub status: ::prost::alloc::string::String,
188    #[prost(string, tag = "2")]
189    pub version: ::prost::alloc::string::String,
190    #[prost(int64, tag = "3")]
191    pub timestamp: i64,
192}
193#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
194pub struct GetStatsRequest {}
195#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
196pub struct GetStatsResponse {
197    #[prost(uint32, tag = "1")]
198    pub collections_count: u32,
199    #[prost(uint64, tag = "2")]
200    pub total_vectors: u64,
201    #[prost(int64, tag = "3")]
202    pub uptime_seconds: i64,
203    #[prost(string, tag = "4")]
204    pub version: ::prost::alloc::string::String,
205}
206/// Common data structures
207#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
208pub struct CollectionConfig {
209    #[prost(uint32, tag = "1")]
210    pub dimension: u32,
211    #[prost(enumeration = "DistanceMetric", tag = "2")]
212    pub metric: i32,
213    #[prost(message, optional, tag = "3")]
214    pub hnsw_config: ::core::option::Option<HnswConfig>,
215    #[prost(message, optional, tag = "4")]
216    pub quantization: ::core::option::Option<QuantizationConfig>,
217    #[prost(enumeration = "StorageType", tag = "5")]
218    pub storage_type: i32,
219}
220#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
221pub struct CollectionInfo {
222    #[prost(string, tag = "1")]
223    pub name: ::prost::alloc::string::String,
224    #[prost(message, optional, tag = "2")]
225    pub config: ::core::option::Option<CollectionConfig>,
226    #[prost(uint64, tag = "3")]
227    pub vector_count: u64,
228    #[prost(int64, tag = "4")]
229    pub created_at: i64,
230    #[prost(int64, tag = "5")]
231    pub updated_at: i64,
232}
233/// SearchResult — downgraded from double→float (f64→f32) in v3.0.0 to match
234/// the canonical `crate::models::SearchResult` precision and HNSW's native
235/// f32 scoring. Breaking wire change — clients built against pre-v3.0.0
236/// proto must regenerate. cluster.proto already used `float` so the two
237/// service surfaces are now consistent.
238#[derive(Clone, PartialEq, ::prost::Message)]
239pub struct SearchResult {
240    #[prost(string, tag = "1")]
241    pub id: ::prost::alloc::string::String,
242    #[prost(float, tag = "2")]
243    pub score: f32,
244    #[prost(float, repeated, tag = "3")]
245    pub vector: ::prost::alloc::vec::Vec<f32>,
246    #[prost(map = "string, string", tag = "4")]
247    pub payload: ::std::collections::HashMap<
248        ::prost::alloc::string::String,
249        ::prost::alloc::string::String,
250    >,
251}
252#[derive(Clone, PartialEq, ::prost::Message)]
253pub struct HybridSearchResult {
254    #[prost(string, tag = "1")]
255    pub id: ::prost::alloc::string::String,
256    #[prost(float, tag = "2")]
257    pub hybrid_score: f32,
258    #[prost(float, tag = "3")]
259    pub dense_score: f32,
260    #[prost(float, tag = "4")]
261    pub sparse_score: f32,
262    #[prost(float, repeated, tag = "5")]
263    pub vector: ::prost::alloc::vec::Vec<f32>,
264    #[prost(map = "string, string", tag = "6")]
265    pub payload: ::std::collections::HashMap<
266        ::prost::alloc::string::String,
267        ::prost::alloc::string::String,
268    >,
269}
270#[derive(Clone, PartialEq, ::prost::Message)]
271pub struct SparseVector {
272    #[prost(uint32, repeated, tag = "1")]
273    pub indices: ::prost::alloc::vec::Vec<u32>,
274    #[prost(float, repeated, tag = "2")]
275    pub values: ::prost::alloc::vec::Vec<f32>,
276}
277#[derive(Clone, Copy, PartialEq, ::prost::Message)]
278pub struct HybridSearchConfig {
279    #[prost(uint32, tag = "1")]
280    pub dense_k: u32,
281    #[prost(uint32, tag = "2")]
282    pub sparse_k: u32,
283    #[prost(uint32, tag = "3")]
284    pub final_k: u32,
285    #[prost(double, tag = "4")]
286    pub alpha: f64,
287    #[prost(enumeration = "HybridScoringAlgorithm", tag = "5")]
288    pub algorithm: i32,
289}
290#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
291pub struct HnswConfig {
292    #[prost(uint32, tag = "1")]
293    pub m: u32,
294    #[prost(uint32, tag = "2")]
295    pub ef_construction: u32,
296    #[prost(uint32, tag = "3")]
297    pub ef: u32,
298    #[prost(uint64, tag = "4")]
299    pub seed: u64,
300}
301#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
302pub struct QuantizationConfig {
303    #[prost(oneof = "quantization_config::Config", tags = "1, 2, 3")]
304    pub config: ::core::option::Option<quantization_config::Config>,
305}
306/// Nested message and enum types in `QuantizationConfig`.
307pub mod quantization_config {
308    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
309    pub enum Config {
310        #[prost(message, tag = "1")]
311        Scalar(super::ScalarQuantization),
312        #[prost(message, tag = "2")]
313        Product(super::ProductQuantization),
314        #[prost(message, tag = "3")]
315        Binary(super::BinaryQuantization),
316    }
317}
318#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
319pub struct ScalarQuantization {
320    #[prost(uint32, tag = "1")]
321    pub bits: u32,
322}
323#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
324pub struct ProductQuantization {
325    #[prost(uint32, tag = "1")]
326    pub subvectors: u32,
327    #[prost(uint32, tag = "2")]
328    pub centroids: u32,
329}
330#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
331pub struct BinaryQuantization {}
332#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
333#[repr(i32)]
334pub enum DistanceMetric {
335    Cosine = 0,
336    Euclidean = 1,
337    DotProduct = 2,
338}
339impl DistanceMetric {
340    /// String value of the enum field names used in the ProtoBuf definition.
341    ///
342    /// The values are not transformed in any way and thus are considered stable
343    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
344    pub fn as_str_name(&self) -> &'static str {
345        match self {
346            Self::Cosine => "COSINE",
347            Self::Euclidean => "EUCLIDEAN",
348            Self::DotProduct => "DOT_PRODUCT",
349        }
350    }
351    /// Creates an enum from field names used in the ProtoBuf definition.
352    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
353        match value {
354            "COSINE" => Some(Self::Cosine),
355            "EUCLIDEAN" => Some(Self::Euclidean),
356            "DOT_PRODUCT" => Some(Self::DotProduct),
357            _ => None,
358        }
359    }
360}
361#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
362#[repr(i32)]
363pub enum StorageType {
364    Memory = 0,
365    Mmap = 1,
366}
367impl StorageType {
368    /// String value of the enum field names used in the ProtoBuf definition.
369    ///
370    /// The values are not transformed in any way and thus are considered stable
371    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
372    pub fn as_str_name(&self) -> &'static str {
373        match self {
374            Self::Memory => "MEMORY",
375            Self::Mmap => "MMAP",
376        }
377    }
378    /// Creates an enum from field names used in the ProtoBuf definition.
379    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
380        match value {
381            "MEMORY" => Some(Self::Memory),
382            "MMAP" => Some(Self::Mmap),
383            _ => None,
384        }
385    }
386}
387#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
388#[repr(i32)]
389pub enum HybridScoringAlgorithm {
390    Rrf = 0,
391    Weighted = 1,
392    AlphaBlend = 2,
393}
394impl HybridScoringAlgorithm {
395    /// String value of the enum field names used in the ProtoBuf definition.
396    ///
397    /// The values are not transformed in any way and thus are considered stable
398    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
399    pub fn as_str_name(&self) -> &'static str {
400        match self {
401            Self::Rrf => "RRF",
402            Self::Weighted => "WEIGHTED",
403            Self::AlphaBlend => "ALPHA_BLEND",
404        }
405    }
406    /// Creates an enum from field names used in the ProtoBuf definition.
407    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
408        match value {
409            "RRF" => Some(Self::Rrf),
410            "WEIGHTED" => Some(Self::Weighted),
411            "ALPHA_BLEND" => Some(Self::AlphaBlend),
412            _ => None,
413        }
414    }
415}
416/// Generated client implementations.
417pub mod vectorizer_service_client {
418    #![allow(
419        unused_variables,
420        dead_code,
421        missing_docs,
422        clippy::wildcard_imports,
423        clippy::let_unit_value,
424    )]
425    use tonic::codegen::*;
426    use tonic::codegen::http::Uri;
427    /// Vectorizer gRPC service definition
428    #[derive(Debug, Clone)]
429    pub struct VectorizerServiceClient<T> {
430        inner: tonic::client::Grpc<T>,
431    }
432    impl VectorizerServiceClient<tonic::transport::Channel> {
433        /// Attempt to create a new client by connecting to a given endpoint.
434        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
435        where
436            D: TryInto<tonic::transport::Endpoint>,
437            D::Error: Into<StdError>,
438        {
439            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
440            Ok(Self::new(conn))
441        }
442    }
443    impl<T> VectorizerServiceClient<T>
444    where
445        T: tonic::client::GrpcService<tonic::body::Body>,
446        T::Error: Into<StdError>,
447        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
448        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
449    {
450        pub fn new(inner: T) -> Self {
451            let inner = tonic::client::Grpc::new(inner);
452            Self { inner }
453        }
454        pub fn with_origin(inner: T, origin: Uri) -> Self {
455            let inner = tonic::client::Grpc::with_origin(inner, origin);
456            Self { inner }
457        }
458        pub fn with_interceptor<F>(
459            inner: T,
460            interceptor: F,
461        ) -> VectorizerServiceClient<InterceptedService<T, F>>
462        where
463            F: tonic::service::Interceptor,
464            T::ResponseBody: Default,
465            T: tonic::codegen::Service<
466                http::Request<tonic::body::Body>,
467                Response = http::Response<
468                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
469                >,
470            >,
471            <T as tonic::codegen::Service<
472                http::Request<tonic::body::Body>,
473            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
474        {
475            VectorizerServiceClient::new(InterceptedService::new(inner, interceptor))
476        }
477        /// Compress requests with the given encoding.
478        ///
479        /// This requires the server to support it otherwise it might respond with an
480        /// error.
481        #[must_use]
482        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
483            self.inner = self.inner.send_compressed(encoding);
484            self
485        }
486        /// Enable decompressing responses.
487        #[must_use]
488        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
489            self.inner = self.inner.accept_compressed(encoding);
490            self
491        }
492        /// Limits the maximum size of a decoded message.
493        ///
494        /// Default: `4MB`
495        #[must_use]
496        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
497            self.inner = self.inner.max_decoding_message_size(limit);
498            self
499        }
500        /// Limits the maximum size of an encoded message.
501        ///
502        /// Default: `usize::MAX`
503        #[must_use]
504        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
505            self.inner = self.inner.max_encoding_message_size(limit);
506            self
507        }
508        /// Collection management
509        pub async fn list_collections(
510            &mut self,
511            request: impl tonic::IntoRequest<super::ListCollectionsRequest>,
512        ) -> std::result::Result<
513            tonic::Response<super::ListCollectionsResponse>,
514            tonic::Status,
515        > {
516            self.inner
517                .ready()
518                .await
519                .map_err(|e| {
520                    tonic::Status::unknown(
521                        format!("Service was not ready: {}", e.into()),
522                    )
523                })?;
524            let codec = tonic_prost::ProstCodec::default();
525            let path = http::uri::PathAndQuery::from_static(
526                "/vectorizer.VectorizerService/ListCollections",
527            );
528            let mut req = request.into_request();
529            req.extensions_mut()
530                .insert(
531                    GrpcMethod::new("vectorizer.VectorizerService", "ListCollections"),
532                );
533            self.inner.unary(req, path, codec).await
534        }
535        pub async fn create_collection(
536            &mut self,
537            request: impl tonic::IntoRequest<super::CreateCollectionRequest>,
538        ) -> std::result::Result<
539            tonic::Response<super::CreateCollectionResponse>,
540            tonic::Status,
541        > {
542            self.inner
543                .ready()
544                .await
545                .map_err(|e| {
546                    tonic::Status::unknown(
547                        format!("Service was not ready: {}", e.into()),
548                    )
549                })?;
550            let codec = tonic_prost::ProstCodec::default();
551            let path = http::uri::PathAndQuery::from_static(
552                "/vectorizer.VectorizerService/CreateCollection",
553            );
554            let mut req = request.into_request();
555            req.extensions_mut()
556                .insert(
557                    GrpcMethod::new("vectorizer.VectorizerService", "CreateCollection"),
558                );
559            self.inner.unary(req, path, codec).await
560        }
561        pub async fn get_collection_info(
562            &mut self,
563            request: impl tonic::IntoRequest<super::GetCollectionInfoRequest>,
564        ) -> std::result::Result<
565            tonic::Response<super::GetCollectionInfoResponse>,
566            tonic::Status,
567        > {
568            self.inner
569                .ready()
570                .await
571                .map_err(|e| {
572                    tonic::Status::unknown(
573                        format!("Service was not ready: {}", e.into()),
574                    )
575                })?;
576            let codec = tonic_prost::ProstCodec::default();
577            let path = http::uri::PathAndQuery::from_static(
578                "/vectorizer.VectorizerService/GetCollectionInfo",
579            );
580            let mut req = request.into_request();
581            req.extensions_mut()
582                .insert(
583                    GrpcMethod::new("vectorizer.VectorizerService", "GetCollectionInfo"),
584                );
585            self.inner.unary(req, path, codec).await
586        }
587        pub async fn delete_collection(
588            &mut self,
589            request: impl tonic::IntoRequest<super::DeleteCollectionRequest>,
590        ) -> std::result::Result<
591            tonic::Response<super::DeleteCollectionResponse>,
592            tonic::Status,
593        > {
594            self.inner
595                .ready()
596                .await
597                .map_err(|e| {
598                    tonic::Status::unknown(
599                        format!("Service was not ready: {}", e.into()),
600                    )
601                })?;
602            let codec = tonic_prost::ProstCodec::default();
603            let path = http::uri::PathAndQuery::from_static(
604                "/vectorizer.VectorizerService/DeleteCollection",
605            );
606            let mut req = request.into_request();
607            req.extensions_mut()
608                .insert(
609                    GrpcMethod::new("vectorizer.VectorizerService", "DeleteCollection"),
610                );
611            self.inner.unary(req, path, codec).await
612        }
613        /// Vector operations
614        pub async fn insert_vector(
615            &mut self,
616            request: impl tonic::IntoRequest<super::InsertVectorRequest>,
617        ) -> std::result::Result<
618            tonic::Response<super::InsertVectorResponse>,
619            tonic::Status,
620        > {
621            self.inner
622                .ready()
623                .await
624                .map_err(|e| {
625                    tonic::Status::unknown(
626                        format!("Service was not ready: {}", e.into()),
627                    )
628                })?;
629            let codec = tonic_prost::ProstCodec::default();
630            let path = http::uri::PathAndQuery::from_static(
631                "/vectorizer.VectorizerService/InsertVector",
632            );
633            let mut req = request.into_request();
634            req.extensions_mut()
635                .insert(GrpcMethod::new("vectorizer.VectorizerService", "InsertVector"));
636            self.inner.unary(req, path, codec).await
637        }
638        pub async fn insert_vectors(
639            &mut self,
640            request: impl tonic::IntoStreamingRequest<
641                Message = super::InsertVectorRequest,
642            >,
643        ) -> std::result::Result<
644            tonic::Response<super::InsertVectorsResponse>,
645            tonic::Status,
646        > {
647            self.inner
648                .ready()
649                .await
650                .map_err(|e| {
651                    tonic::Status::unknown(
652                        format!("Service was not ready: {}", e.into()),
653                    )
654                })?;
655            let codec = tonic_prost::ProstCodec::default();
656            let path = http::uri::PathAndQuery::from_static(
657                "/vectorizer.VectorizerService/InsertVectors",
658            );
659            let mut req = request.into_streaming_request();
660            req.extensions_mut()
661                .insert(
662                    GrpcMethod::new("vectorizer.VectorizerService", "InsertVectors"),
663                );
664            self.inner.client_streaming(req, path, codec).await
665        }
666        pub async fn get_vector(
667            &mut self,
668            request: impl tonic::IntoRequest<super::GetVectorRequest>,
669        ) -> std::result::Result<
670            tonic::Response<super::GetVectorResponse>,
671            tonic::Status,
672        > {
673            self.inner
674                .ready()
675                .await
676                .map_err(|e| {
677                    tonic::Status::unknown(
678                        format!("Service was not ready: {}", e.into()),
679                    )
680                })?;
681            let codec = tonic_prost::ProstCodec::default();
682            let path = http::uri::PathAndQuery::from_static(
683                "/vectorizer.VectorizerService/GetVector",
684            );
685            let mut req = request.into_request();
686            req.extensions_mut()
687                .insert(GrpcMethod::new("vectorizer.VectorizerService", "GetVector"));
688            self.inner.unary(req, path, codec).await
689        }
690        pub async fn update_vector(
691            &mut self,
692            request: impl tonic::IntoRequest<super::UpdateVectorRequest>,
693        ) -> std::result::Result<
694            tonic::Response<super::UpdateVectorResponse>,
695            tonic::Status,
696        > {
697            self.inner
698                .ready()
699                .await
700                .map_err(|e| {
701                    tonic::Status::unknown(
702                        format!("Service was not ready: {}", e.into()),
703                    )
704                })?;
705            let codec = tonic_prost::ProstCodec::default();
706            let path = http::uri::PathAndQuery::from_static(
707                "/vectorizer.VectorizerService/UpdateVector",
708            );
709            let mut req = request.into_request();
710            req.extensions_mut()
711                .insert(GrpcMethod::new("vectorizer.VectorizerService", "UpdateVector"));
712            self.inner.unary(req, path, codec).await
713        }
714        pub async fn delete_vector(
715            &mut self,
716            request: impl tonic::IntoRequest<super::DeleteVectorRequest>,
717        ) -> std::result::Result<
718            tonic::Response<super::DeleteVectorResponse>,
719            tonic::Status,
720        > {
721            self.inner
722                .ready()
723                .await
724                .map_err(|e| {
725                    tonic::Status::unknown(
726                        format!("Service was not ready: {}", e.into()),
727                    )
728                })?;
729            let codec = tonic_prost::ProstCodec::default();
730            let path = http::uri::PathAndQuery::from_static(
731                "/vectorizer.VectorizerService/DeleteVector",
732            );
733            let mut req = request.into_request();
734            req.extensions_mut()
735                .insert(GrpcMethod::new("vectorizer.VectorizerService", "DeleteVector"));
736            self.inner.unary(req, path, codec).await
737        }
738        /// Search operations
739        pub async fn search(
740            &mut self,
741            request: impl tonic::IntoRequest<super::SearchRequest>,
742        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
743            self.inner
744                .ready()
745                .await
746                .map_err(|e| {
747                    tonic::Status::unknown(
748                        format!("Service was not ready: {}", e.into()),
749                    )
750                })?;
751            let codec = tonic_prost::ProstCodec::default();
752            let path = http::uri::PathAndQuery::from_static(
753                "/vectorizer.VectorizerService/Search",
754            );
755            let mut req = request.into_request();
756            req.extensions_mut()
757                .insert(GrpcMethod::new("vectorizer.VectorizerService", "Search"));
758            self.inner.unary(req, path, codec).await
759        }
760        pub async fn batch_search(
761            &mut self,
762            request: impl tonic::IntoRequest<super::BatchSearchRequest>,
763        ) -> std::result::Result<
764            tonic::Response<super::BatchSearchResponse>,
765            tonic::Status,
766        > {
767            self.inner
768                .ready()
769                .await
770                .map_err(|e| {
771                    tonic::Status::unknown(
772                        format!("Service was not ready: {}", e.into()),
773                    )
774                })?;
775            let codec = tonic_prost::ProstCodec::default();
776            let path = http::uri::PathAndQuery::from_static(
777                "/vectorizer.VectorizerService/BatchSearch",
778            );
779            let mut req = request.into_request();
780            req.extensions_mut()
781                .insert(GrpcMethod::new("vectorizer.VectorizerService", "BatchSearch"));
782            self.inner.unary(req, path, codec).await
783        }
784        pub async fn hybrid_search(
785            &mut self,
786            request: impl tonic::IntoRequest<super::HybridSearchRequest>,
787        ) -> std::result::Result<
788            tonic::Response<super::HybridSearchResponse>,
789            tonic::Status,
790        > {
791            self.inner
792                .ready()
793                .await
794                .map_err(|e| {
795                    tonic::Status::unknown(
796                        format!("Service was not ready: {}", e.into()),
797                    )
798                })?;
799            let codec = tonic_prost::ProstCodec::default();
800            let path = http::uri::PathAndQuery::from_static(
801                "/vectorizer.VectorizerService/HybridSearch",
802            );
803            let mut req = request.into_request();
804            req.extensions_mut()
805                .insert(GrpcMethod::new("vectorizer.VectorizerService", "HybridSearch"));
806            self.inner.unary(req, path, codec).await
807        }
808        /// Health and stats
809        pub async fn health_check(
810            &mut self,
811            request: impl tonic::IntoRequest<super::HealthCheckRequest>,
812        ) -> std::result::Result<
813            tonic::Response<super::HealthCheckResponse>,
814            tonic::Status,
815        > {
816            self.inner
817                .ready()
818                .await
819                .map_err(|e| {
820                    tonic::Status::unknown(
821                        format!("Service was not ready: {}", e.into()),
822                    )
823                })?;
824            let codec = tonic_prost::ProstCodec::default();
825            let path = http::uri::PathAndQuery::from_static(
826                "/vectorizer.VectorizerService/HealthCheck",
827            );
828            let mut req = request.into_request();
829            req.extensions_mut()
830                .insert(GrpcMethod::new("vectorizer.VectorizerService", "HealthCheck"));
831            self.inner.unary(req, path, codec).await
832        }
833        pub async fn get_stats(
834            &mut self,
835            request: impl tonic::IntoRequest<super::GetStatsRequest>,
836        ) -> std::result::Result<
837            tonic::Response<super::GetStatsResponse>,
838            tonic::Status,
839        > {
840            self.inner
841                .ready()
842                .await
843                .map_err(|e| {
844                    tonic::Status::unknown(
845                        format!("Service was not ready: {}", e.into()),
846                    )
847                })?;
848            let codec = tonic_prost::ProstCodec::default();
849            let path = http::uri::PathAndQuery::from_static(
850                "/vectorizer.VectorizerService/GetStats",
851            );
852            let mut req = request.into_request();
853            req.extensions_mut()
854                .insert(GrpcMethod::new("vectorizer.VectorizerService", "GetStats"));
855            self.inner.unary(req, path, codec).await
856        }
857    }
858}
859/// Generated server implementations.
860pub mod vectorizer_service_server {
861    #![allow(
862        unused_variables,
863        dead_code,
864        missing_docs,
865        clippy::wildcard_imports,
866        clippy::let_unit_value,
867    )]
868    use tonic::codegen::*;
869    /// Generated trait containing gRPC methods that should be implemented for use with VectorizerServiceServer.
870    #[async_trait]
871    pub trait VectorizerService: std::marker::Send + std::marker::Sync + 'static {
872        /// Collection management
873        async fn list_collections(
874            &self,
875            request: tonic::Request<super::ListCollectionsRequest>,
876        ) -> std::result::Result<
877            tonic::Response<super::ListCollectionsResponse>,
878            tonic::Status,
879        >;
880        async fn create_collection(
881            &self,
882            request: tonic::Request<super::CreateCollectionRequest>,
883        ) -> std::result::Result<
884            tonic::Response<super::CreateCollectionResponse>,
885            tonic::Status,
886        >;
887        async fn get_collection_info(
888            &self,
889            request: tonic::Request<super::GetCollectionInfoRequest>,
890        ) -> std::result::Result<
891            tonic::Response<super::GetCollectionInfoResponse>,
892            tonic::Status,
893        >;
894        async fn delete_collection(
895            &self,
896            request: tonic::Request<super::DeleteCollectionRequest>,
897        ) -> std::result::Result<
898            tonic::Response<super::DeleteCollectionResponse>,
899            tonic::Status,
900        >;
901        /// Vector operations
902        async fn insert_vector(
903            &self,
904            request: tonic::Request<super::InsertVectorRequest>,
905        ) -> std::result::Result<
906            tonic::Response<super::InsertVectorResponse>,
907            tonic::Status,
908        >;
909        async fn insert_vectors(
910            &self,
911            request: tonic::Request<tonic::Streaming<super::InsertVectorRequest>>,
912        ) -> std::result::Result<
913            tonic::Response<super::InsertVectorsResponse>,
914            tonic::Status,
915        >;
916        async fn get_vector(
917            &self,
918            request: tonic::Request<super::GetVectorRequest>,
919        ) -> std::result::Result<
920            tonic::Response<super::GetVectorResponse>,
921            tonic::Status,
922        >;
923        async fn update_vector(
924            &self,
925            request: tonic::Request<super::UpdateVectorRequest>,
926        ) -> std::result::Result<
927            tonic::Response<super::UpdateVectorResponse>,
928            tonic::Status,
929        >;
930        async fn delete_vector(
931            &self,
932            request: tonic::Request<super::DeleteVectorRequest>,
933        ) -> std::result::Result<
934            tonic::Response<super::DeleteVectorResponse>,
935            tonic::Status,
936        >;
937        /// Search operations
938        async fn search(
939            &self,
940            request: tonic::Request<super::SearchRequest>,
941        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>;
942        async fn batch_search(
943            &self,
944            request: tonic::Request<super::BatchSearchRequest>,
945        ) -> std::result::Result<
946            tonic::Response<super::BatchSearchResponse>,
947            tonic::Status,
948        >;
949        async fn hybrid_search(
950            &self,
951            request: tonic::Request<super::HybridSearchRequest>,
952        ) -> std::result::Result<
953            tonic::Response<super::HybridSearchResponse>,
954            tonic::Status,
955        >;
956        /// Health and stats
957        async fn health_check(
958            &self,
959            request: tonic::Request<super::HealthCheckRequest>,
960        ) -> std::result::Result<
961            tonic::Response<super::HealthCheckResponse>,
962            tonic::Status,
963        >;
964        async fn get_stats(
965            &self,
966            request: tonic::Request<super::GetStatsRequest>,
967        ) -> std::result::Result<
968            tonic::Response<super::GetStatsResponse>,
969            tonic::Status,
970        >;
971    }
972    /// Vectorizer gRPC service definition
973    #[derive(Debug)]
974    pub struct VectorizerServiceServer<T> {
975        inner: Arc<T>,
976        accept_compression_encodings: EnabledCompressionEncodings,
977        send_compression_encodings: EnabledCompressionEncodings,
978        max_decoding_message_size: Option<usize>,
979        max_encoding_message_size: Option<usize>,
980    }
981    impl<T> VectorizerServiceServer<T> {
982        pub fn new(inner: T) -> Self {
983            Self::from_arc(Arc::new(inner))
984        }
985        pub fn from_arc(inner: Arc<T>) -> Self {
986            Self {
987                inner,
988                accept_compression_encodings: Default::default(),
989                send_compression_encodings: Default::default(),
990                max_decoding_message_size: None,
991                max_encoding_message_size: None,
992            }
993        }
994        pub fn with_interceptor<F>(
995            inner: T,
996            interceptor: F,
997        ) -> InterceptedService<Self, F>
998        where
999            F: tonic::service::Interceptor,
1000        {
1001            InterceptedService::new(Self::new(inner), interceptor)
1002        }
1003        /// Enable decompressing requests with the given encoding.
1004        #[must_use]
1005        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1006            self.accept_compression_encodings.enable(encoding);
1007            self
1008        }
1009        /// Compress responses with the given encoding, if the client supports it.
1010        #[must_use]
1011        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1012            self.send_compression_encodings.enable(encoding);
1013            self
1014        }
1015        /// Limits the maximum size of a decoded message.
1016        ///
1017        /// Default: `4MB`
1018        #[must_use]
1019        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1020            self.max_decoding_message_size = Some(limit);
1021            self
1022        }
1023        /// Limits the maximum size of an encoded message.
1024        ///
1025        /// Default: `usize::MAX`
1026        #[must_use]
1027        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1028            self.max_encoding_message_size = Some(limit);
1029            self
1030        }
1031    }
1032    impl<T, B> tonic::codegen::Service<http::Request<B>> for VectorizerServiceServer<T>
1033    where
1034        T: VectorizerService,
1035        B: Body + std::marker::Send + 'static,
1036        B::Error: Into<StdError> + std::marker::Send + 'static,
1037    {
1038        type Response = http::Response<tonic::body::Body>;
1039        type Error = std::convert::Infallible;
1040        type Future = BoxFuture<Self::Response, Self::Error>;
1041        fn poll_ready(
1042            &mut self,
1043            _cx: &mut Context<'_>,
1044        ) -> Poll<std::result::Result<(), Self::Error>> {
1045            Poll::Ready(Ok(()))
1046        }
1047        fn call(&mut self, req: http::Request<B>) -> Self::Future {
1048            match req.uri().path() {
1049                "/vectorizer.VectorizerService/ListCollections" => {
1050                    #[allow(non_camel_case_types)]
1051                    struct ListCollectionsSvc<T: VectorizerService>(pub Arc<T>);
1052                    impl<
1053                        T: VectorizerService,
1054                    > tonic::server::UnaryService<super::ListCollectionsRequest>
1055                    for ListCollectionsSvc<T> {
1056                        type Response = super::ListCollectionsResponse;
1057                        type Future = BoxFuture<
1058                            tonic::Response<Self::Response>,
1059                            tonic::Status,
1060                        >;
1061                        fn call(
1062                            &mut self,
1063                            request: tonic::Request<super::ListCollectionsRequest>,
1064                        ) -> Self::Future {
1065                            let inner = Arc::clone(&self.0);
1066                            let fut = async move {
1067                                <T as VectorizerService>::list_collections(&inner, request)
1068                                    .await
1069                            };
1070                            Box::pin(fut)
1071                        }
1072                    }
1073                    let accept_compression_encodings = self.accept_compression_encodings;
1074                    let send_compression_encodings = self.send_compression_encodings;
1075                    let max_decoding_message_size = self.max_decoding_message_size;
1076                    let max_encoding_message_size = self.max_encoding_message_size;
1077                    let inner = self.inner.clone();
1078                    let fut = async move {
1079                        let method = ListCollectionsSvc(inner);
1080                        let codec = tonic_prost::ProstCodec::default();
1081                        let mut grpc = tonic::server::Grpc::new(codec)
1082                            .apply_compression_config(
1083                                accept_compression_encodings,
1084                                send_compression_encodings,
1085                            )
1086                            .apply_max_message_size_config(
1087                                max_decoding_message_size,
1088                                max_encoding_message_size,
1089                            );
1090                        let res = grpc.unary(method, req).await;
1091                        Ok(res)
1092                    };
1093                    Box::pin(fut)
1094                }
1095                "/vectorizer.VectorizerService/CreateCollection" => {
1096                    #[allow(non_camel_case_types)]
1097                    struct CreateCollectionSvc<T: VectorizerService>(pub Arc<T>);
1098                    impl<
1099                        T: VectorizerService,
1100                    > tonic::server::UnaryService<super::CreateCollectionRequest>
1101                    for CreateCollectionSvc<T> {
1102                        type Response = super::CreateCollectionResponse;
1103                        type Future = BoxFuture<
1104                            tonic::Response<Self::Response>,
1105                            tonic::Status,
1106                        >;
1107                        fn call(
1108                            &mut self,
1109                            request: tonic::Request<super::CreateCollectionRequest>,
1110                        ) -> Self::Future {
1111                            let inner = Arc::clone(&self.0);
1112                            let fut = async move {
1113                                <T as VectorizerService>::create_collection(&inner, request)
1114                                    .await
1115                            };
1116                            Box::pin(fut)
1117                        }
1118                    }
1119                    let accept_compression_encodings = self.accept_compression_encodings;
1120                    let send_compression_encodings = self.send_compression_encodings;
1121                    let max_decoding_message_size = self.max_decoding_message_size;
1122                    let max_encoding_message_size = self.max_encoding_message_size;
1123                    let inner = self.inner.clone();
1124                    let fut = async move {
1125                        let method = CreateCollectionSvc(inner);
1126                        let codec = tonic_prost::ProstCodec::default();
1127                        let mut grpc = tonic::server::Grpc::new(codec)
1128                            .apply_compression_config(
1129                                accept_compression_encodings,
1130                                send_compression_encodings,
1131                            )
1132                            .apply_max_message_size_config(
1133                                max_decoding_message_size,
1134                                max_encoding_message_size,
1135                            );
1136                        let res = grpc.unary(method, req).await;
1137                        Ok(res)
1138                    };
1139                    Box::pin(fut)
1140                }
1141                "/vectorizer.VectorizerService/GetCollectionInfo" => {
1142                    #[allow(non_camel_case_types)]
1143                    struct GetCollectionInfoSvc<T: VectorizerService>(pub Arc<T>);
1144                    impl<
1145                        T: VectorizerService,
1146                    > tonic::server::UnaryService<super::GetCollectionInfoRequest>
1147                    for GetCollectionInfoSvc<T> {
1148                        type Response = super::GetCollectionInfoResponse;
1149                        type Future = BoxFuture<
1150                            tonic::Response<Self::Response>,
1151                            tonic::Status,
1152                        >;
1153                        fn call(
1154                            &mut self,
1155                            request: tonic::Request<super::GetCollectionInfoRequest>,
1156                        ) -> Self::Future {
1157                            let inner = Arc::clone(&self.0);
1158                            let fut = async move {
1159                                <T as VectorizerService>::get_collection_info(
1160                                        &inner,
1161                                        request,
1162                                    )
1163                                    .await
1164                            };
1165                            Box::pin(fut)
1166                        }
1167                    }
1168                    let accept_compression_encodings = self.accept_compression_encodings;
1169                    let send_compression_encodings = self.send_compression_encodings;
1170                    let max_decoding_message_size = self.max_decoding_message_size;
1171                    let max_encoding_message_size = self.max_encoding_message_size;
1172                    let inner = self.inner.clone();
1173                    let fut = async move {
1174                        let method = GetCollectionInfoSvc(inner);
1175                        let codec = tonic_prost::ProstCodec::default();
1176                        let mut grpc = tonic::server::Grpc::new(codec)
1177                            .apply_compression_config(
1178                                accept_compression_encodings,
1179                                send_compression_encodings,
1180                            )
1181                            .apply_max_message_size_config(
1182                                max_decoding_message_size,
1183                                max_encoding_message_size,
1184                            );
1185                        let res = grpc.unary(method, req).await;
1186                        Ok(res)
1187                    };
1188                    Box::pin(fut)
1189                }
1190                "/vectorizer.VectorizerService/DeleteCollection" => {
1191                    #[allow(non_camel_case_types)]
1192                    struct DeleteCollectionSvc<T: VectorizerService>(pub Arc<T>);
1193                    impl<
1194                        T: VectorizerService,
1195                    > tonic::server::UnaryService<super::DeleteCollectionRequest>
1196                    for DeleteCollectionSvc<T> {
1197                        type Response = super::DeleteCollectionResponse;
1198                        type Future = BoxFuture<
1199                            tonic::Response<Self::Response>,
1200                            tonic::Status,
1201                        >;
1202                        fn call(
1203                            &mut self,
1204                            request: tonic::Request<super::DeleteCollectionRequest>,
1205                        ) -> Self::Future {
1206                            let inner = Arc::clone(&self.0);
1207                            let fut = async move {
1208                                <T as VectorizerService>::delete_collection(&inner, request)
1209                                    .await
1210                            };
1211                            Box::pin(fut)
1212                        }
1213                    }
1214                    let accept_compression_encodings = self.accept_compression_encodings;
1215                    let send_compression_encodings = self.send_compression_encodings;
1216                    let max_decoding_message_size = self.max_decoding_message_size;
1217                    let max_encoding_message_size = self.max_encoding_message_size;
1218                    let inner = self.inner.clone();
1219                    let fut = async move {
1220                        let method = DeleteCollectionSvc(inner);
1221                        let codec = tonic_prost::ProstCodec::default();
1222                        let mut grpc = tonic::server::Grpc::new(codec)
1223                            .apply_compression_config(
1224                                accept_compression_encodings,
1225                                send_compression_encodings,
1226                            )
1227                            .apply_max_message_size_config(
1228                                max_decoding_message_size,
1229                                max_encoding_message_size,
1230                            );
1231                        let res = grpc.unary(method, req).await;
1232                        Ok(res)
1233                    };
1234                    Box::pin(fut)
1235                }
1236                "/vectorizer.VectorizerService/InsertVector" => {
1237                    #[allow(non_camel_case_types)]
1238                    struct InsertVectorSvc<T: VectorizerService>(pub Arc<T>);
1239                    impl<
1240                        T: VectorizerService,
1241                    > tonic::server::UnaryService<super::InsertVectorRequest>
1242                    for InsertVectorSvc<T> {
1243                        type Response = super::InsertVectorResponse;
1244                        type Future = BoxFuture<
1245                            tonic::Response<Self::Response>,
1246                            tonic::Status,
1247                        >;
1248                        fn call(
1249                            &mut self,
1250                            request: tonic::Request<super::InsertVectorRequest>,
1251                        ) -> Self::Future {
1252                            let inner = Arc::clone(&self.0);
1253                            let fut = async move {
1254                                <T as VectorizerService>::insert_vector(&inner, request)
1255                                    .await
1256                            };
1257                            Box::pin(fut)
1258                        }
1259                    }
1260                    let accept_compression_encodings = self.accept_compression_encodings;
1261                    let send_compression_encodings = self.send_compression_encodings;
1262                    let max_decoding_message_size = self.max_decoding_message_size;
1263                    let max_encoding_message_size = self.max_encoding_message_size;
1264                    let inner = self.inner.clone();
1265                    let fut = async move {
1266                        let method = InsertVectorSvc(inner);
1267                        let codec = tonic_prost::ProstCodec::default();
1268                        let mut grpc = tonic::server::Grpc::new(codec)
1269                            .apply_compression_config(
1270                                accept_compression_encodings,
1271                                send_compression_encodings,
1272                            )
1273                            .apply_max_message_size_config(
1274                                max_decoding_message_size,
1275                                max_encoding_message_size,
1276                            );
1277                        let res = grpc.unary(method, req).await;
1278                        Ok(res)
1279                    };
1280                    Box::pin(fut)
1281                }
1282                "/vectorizer.VectorizerService/InsertVectors" => {
1283                    #[allow(non_camel_case_types)]
1284                    struct InsertVectorsSvc<T: VectorizerService>(pub Arc<T>);
1285                    impl<
1286                        T: VectorizerService,
1287                    > tonic::server::ClientStreamingService<super::InsertVectorRequest>
1288                    for InsertVectorsSvc<T> {
1289                        type Response = super::InsertVectorsResponse;
1290                        type Future = BoxFuture<
1291                            tonic::Response<Self::Response>,
1292                            tonic::Status,
1293                        >;
1294                        fn call(
1295                            &mut self,
1296                            request: tonic::Request<
1297                                tonic::Streaming<super::InsertVectorRequest>,
1298                            >,
1299                        ) -> Self::Future {
1300                            let inner = Arc::clone(&self.0);
1301                            let fut = async move {
1302                                <T as VectorizerService>::insert_vectors(&inner, request)
1303                                    .await
1304                            };
1305                            Box::pin(fut)
1306                        }
1307                    }
1308                    let accept_compression_encodings = self.accept_compression_encodings;
1309                    let send_compression_encodings = self.send_compression_encodings;
1310                    let max_decoding_message_size = self.max_decoding_message_size;
1311                    let max_encoding_message_size = self.max_encoding_message_size;
1312                    let inner = self.inner.clone();
1313                    let fut = async move {
1314                        let method = InsertVectorsSvc(inner);
1315                        let codec = tonic_prost::ProstCodec::default();
1316                        let mut grpc = tonic::server::Grpc::new(codec)
1317                            .apply_compression_config(
1318                                accept_compression_encodings,
1319                                send_compression_encodings,
1320                            )
1321                            .apply_max_message_size_config(
1322                                max_decoding_message_size,
1323                                max_encoding_message_size,
1324                            );
1325                        let res = grpc.client_streaming(method, req).await;
1326                        Ok(res)
1327                    };
1328                    Box::pin(fut)
1329                }
1330                "/vectorizer.VectorizerService/GetVector" => {
1331                    #[allow(non_camel_case_types)]
1332                    struct GetVectorSvc<T: VectorizerService>(pub Arc<T>);
1333                    impl<
1334                        T: VectorizerService,
1335                    > tonic::server::UnaryService<super::GetVectorRequest>
1336                    for GetVectorSvc<T> {
1337                        type Response = super::GetVectorResponse;
1338                        type Future = BoxFuture<
1339                            tonic::Response<Self::Response>,
1340                            tonic::Status,
1341                        >;
1342                        fn call(
1343                            &mut self,
1344                            request: tonic::Request<super::GetVectorRequest>,
1345                        ) -> Self::Future {
1346                            let inner = Arc::clone(&self.0);
1347                            let fut = async move {
1348                                <T as VectorizerService>::get_vector(&inner, request).await
1349                            };
1350                            Box::pin(fut)
1351                        }
1352                    }
1353                    let accept_compression_encodings = self.accept_compression_encodings;
1354                    let send_compression_encodings = self.send_compression_encodings;
1355                    let max_decoding_message_size = self.max_decoding_message_size;
1356                    let max_encoding_message_size = self.max_encoding_message_size;
1357                    let inner = self.inner.clone();
1358                    let fut = async move {
1359                        let method = GetVectorSvc(inner);
1360                        let codec = tonic_prost::ProstCodec::default();
1361                        let mut grpc = tonic::server::Grpc::new(codec)
1362                            .apply_compression_config(
1363                                accept_compression_encodings,
1364                                send_compression_encodings,
1365                            )
1366                            .apply_max_message_size_config(
1367                                max_decoding_message_size,
1368                                max_encoding_message_size,
1369                            );
1370                        let res = grpc.unary(method, req).await;
1371                        Ok(res)
1372                    };
1373                    Box::pin(fut)
1374                }
1375                "/vectorizer.VectorizerService/UpdateVector" => {
1376                    #[allow(non_camel_case_types)]
1377                    struct UpdateVectorSvc<T: VectorizerService>(pub Arc<T>);
1378                    impl<
1379                        T: VectorizerService,
1380                    > tonic::server::UnaryService<super::UpdateVectorRequest>
1381                    for UpdateVectorSvc<T> {
1382                        type Response = super::UpdateVectorResponse;
1383                        type Future = BoxFuture<
1384                            tonic::Response<Self::Response>,
1385                            tonic::Status,
1386                        >;
1387                        fn call(
1388                            &mut self,
1389                            request: tonic::Request<super::UpdateVectorRequest>,
1390                        ) -> Self::Future {
1391                            let inner = Arc::clone(&self.0);
1392                            let fut = async move {
1393                                <T as VectorizerService>::update_vector(&inner, request)
1394                                    .await
1395                            };
1396                            Box::pin(fut)
1397                        }
1398                    }
1399                    let accept_compression_encodings = self.accept_compression_encodings;
1400                    let send_compression_encodings = self.send_compression_encodings;
1401                    let max_decoding_message_size = self.max_decoding_message_size;
1402                    let max_encoding_message_size = self.max_encoding_message_size;
1403                    let inner = self.inner.clone();
1404                    let fut = async move {
1405                        let method = UpdateVectorSvc(inner);
1406                        let codec = tonic_prost::ProstCodec::default();
1407                        let mut grpc = tonic::server::Grpc::new(codec)
1408                            .apply_compression_config(
1409                                accept_compression_encodings,
1410                                send_compression_encodings,
1411                            )
1412                            .apply_max_message_size_config(
1413                                max_decoding_message_size,
1414                                max_encoding_message_size,
1415                            );
1416                        let res = grpc.unary(method, req).await;
1417                        Ok(res)
1418                    };
1419                    Box::pin(fut)
1420                }
1421                "/vectorizer.VectorizerService/DeleteVector" => {
1422                    #[allow(non_camel_case_types)]
1423                    struct DeleteVectorSvc<T: VectorizerService>(pub Arc<T>);
1424                    impl<
1425                        T: VectorizerService,
1426                    > tonic::server::UnaryService<super::DeleteVectorRequest>
1427                    for DeleteVectorSvc<T> {
1428                        type Response = super::DeleteVectorResponse;
1429                        type Future = BoxFuture<
1430                            tonic::Response<Self::Response>,
1431                            tonic::Status,
1432                        >;
1433                        fn call(
1434                            &mut self,
1435                            request: tonic::Request<super::DeleteVectorRequest>,
1436                        ) -> Self::Future {
1437                            let inner = Arc::clone(&self.0);
1438                            let fut = async move {
1439                                <T as VectorizerService>::delete_vector(&inner, request)
1440                                    .await
1441                            };
1442                            Box::pin(fut)
1443                        }
1444                    }
1445                    let accept_compression_encodings = self.accept_compression_encodings;
1446                    let send_compression_encodings = self.send_compression_encodings;
1447                    let max_decoding_message_size = self.max_decoding_message_size;
1448                    let max_encoding_message_size = self.max_encoding_message_size;
1449                    let inner = self.inner.clone();
1450                    let fut = async move {
1451                        let method = DeleteVectorSvc(inner);
1452                        let codec = tonic_prost::ProstCodec::default();
1453                        let mut grpc = tonic::server::Grpc::new(codec)
1454                            .apply_compression_config(
1455                                accept_compression_encodings,
1456                                send_compression_encodings,
1457                            )
1458                            .apply_max_message_size_config(
1459                                max_decoding_message_size,
1460                                max_encoding_message_size,
1461                            );
1462                        let res = grpc.unary(method, req).await;
1463                        Ok(res)
1464                    };
1465                    Box::pin(fut)
1466                }
1467                "/vectorizer.VectorizerService/Search" => {
1468                    #[allow(non_camel_case_types)]
1469                    struct SearchSvc<T: VectorizerService>(pub Arc<T>);
1470                    impl<
1471                        T: VectorizerService,
1472                    > tonic::server::UnaryService<super::SearchRequest>
1473                    for SearchSvc<T> {
1474                        type Response = super::SearchResponse;
1475                        type Future = BoxFuture<
1476                            tonic::Response<Self::Response>,
1477                            tonic::Status,
1478                        >;
1479                        fn call(
1480                            &mut self,
1481                            request: tonic::Request<super::SearchRequest>,
1482                        ) -> Self::Future {
1483                            let inner = Arc::clone(&self.0);
1484                            let fut = async move {
1485                                <T as VectorizerService>::search(&inner, request).await
1486                            };
1487                            Box::pin(fut)
1488                        }
1489                    }
1490                    let accept_compression_encodings = self.accept_compression_encodings;
1491                    let send_compression_encodings = self.send_compression_encodings;
1492                    let max_decoding_message_size = self.max_decoding_message_size;
1493                    let max_encoding_message_size = self.max_encoding_message_size;
1494                    let inner = self.inner.clone();
1495                    let fut = async move {
1496                        let method = SearchSvc(inner);
1497                        let codec = tonic_prost::ProstCodec::default();
1498                        let mut grpc = tonic::server::Grpc::new(codec)
1499                            .apply_compression_config(
1500                                accept_compression_encodings,
1501                                send_compression_encodings,
1502                            )
1503                            .apply_max_message_size_config(
1504                                max_decoding_message_size,
1505                                max_encoding_message_size,
1506                            );
1507                        let res = grpc.unary(method, req).await;
1508                        Ok(res)
1509                    };
1510                    Box::pin(fut)
1511                }
1512                "/vectorizer.VectorizerService/BatchSearch" => {
1513                    #[allow(non_camel_case_types)]
1514                    struct BatchSearchSvc<T: VectorizerService>(pub Arc<T>);
1515                    impl<
1516                        T: VectorizerService,
1517                    > tonic::server::UnaryService<super::BatchSearchRequest>
1518                    for BatchSearchSvc<T> {
1519                        type Response = super::BatchSearchResponse;
1520                        type Future = BoxFuture<
1521                            tonic::Response<Self::Response>,
1522                            tonic::Status,
1523                        >;
1524                        fn call(
1525                            &mut self,
1526                            request: tonic::Request<super::BatchSearchRequest>,
1527                        ) -> Self::Future {
1528                            let inner = Arc::clone(&self.0);
1529                            let fut = async move {
1530                                <T as VectorizerService>::batch_search(&inner, request)
1531                                    .await
1532                            };
1533                            Box::pin(fut)
1534                        }
1535                    }
1536                    let accept_compression_encodings = self.accept_compression_encodings;
1537                    let send_compression_encodings = self.send_compression_encodings;
1538                    let max_decoding_message_size = self.max_decoding_message_size;
1539                    let max_encoding_message_size = self.max_encoding_message_size;
1540                    let inner = self.inner.clone();
1541                    let fut = async move {
1542                        let method = BatchSearchSvc(inner);
1543                        let codec = tonic_prost::ProstCodec::default();
1544                        let mut grpc = tonic::server::Grpc::new(codec)
1545                            .apply_compression_config(
1546                                accept_compression_encodings,
1547                                send_compression_encodings,
1548                            )
1549                            .apply_max_message_size_config(
1550                                max_decoding_message_size,
1551                                max_encoding_message_size,
1552                            );
1553                        let res = grpc.unary(method, req).await;
1554                        Ok(res)
1555                    };
1556                    Box::pin(fut)
1557                }
1558                "/vectorizer.VectorizerService/HybridSearch" => {
1559                    #[allow(non_camel_case_types)]
1560                    struct HybridSearchSvc<T: VectorizerService>(pub Arc<T>);
1561                    impl<
1562                        T: VectorizerService,
1563                    > tonic::server::UnaryService<super::HybridSearchRequest>
1564                    for HybridSearchSvc<T> {
1565                        type Response = super::HybridSearchResponse;
1566                        type Future = BoxFuture<
1567                            tonic::Response<Self::Response>,
1568                            tonic::Status,
1569                        >;
1570                        fn call(
1571                            &mut self,
1572                            request: tonic::Request<super::HybridSearchRequest>,
1573                        ) -> Self::Future {
1574                            let inner = Arc::clone(&self.0);
1575                            let fut = async move {
1576                                <T as VectorizerService>::hybrid_search(&inner, request)
1577                                    .await
1578                            };
1579                            Box::pin(fut)
1580                        }
1581                    }
1582                    let accept_compression_encodings = self.accept_compression_encodings;
1583                    let send_compression_encodings = self.send_compression_encodings;
1584                    let max_decoding_message_size = self.max_decoding_message_size;
1585                    let max_encoding_message_size = self.max_encoding_message_size;
1586                    let inner = self.inner.clone();
1587                    let fut = async move {
1588                        let method = HybridSearchSvc(inner);
1589                        let codec = tonic_prost::ProstCodec::default();
1590                        let mut grpc = tonic::server::Grpc::new(codec)
1591                            .apply_compression_config(
1592                                accept_compression_encodings,
1593                                send_compression_encodings,
1594                            )
1595                            .apply_max_message_size_config(
1596                                max_decoding_message_size,
1597                                max_encoding_message_size,
1598                            );
1599                        let res = grpc.unary(method, req).await;
1600                        Ok(res)
1601                    };
1602                    Box::pin(fut)
1603                }
1604                "/vectorizer.VectorizerService/HealthCheck" => {
1605                    #[allow(non_camel_case_types)]
1606                    struct HealthCheckSvc<T: VectorizerService>(pub Arc<T>);
1607                    impl<
1608                        T: VectorizerService,
1609                    > tonic::server::UnaryService<super::HealthCheckRequest>
1610                    for HealthCheckSvc<T> {
1611                        type Response = super::HealthCheckResponse;
1612                        type Future = BoxFuture<
1613                            tonic::Response<Self::Response>,
1614                            tonic::Status,
1615                        >;
1616                        fn call(
1617                            &mut self,
1618                            request: tonic::Request<super::HealthCheckRequest>,
1619                        ) -> Self::Future {
1620                            let inner = Arc::clone(&self.0);
1621                            let fut = async move {
1622                                <T as VectorizerService>::health_check(&inner, request)
1623                                    .await
1624                            };
1625                            Box::pin(fut)
1626                        }
1627                    }
1628                    let accept_compression_encodings = self.accept_compression_encodings;
1629                    let send_compression_encodings = self.send_compression_encodings;
1630                    let max_decoding_message_size = self.max_decoding_message_size;
1631                    let max_encoding_message_size = self.max_encoding_message_size;
1632                    let inner = self.inner.clone();
1633                    let fut = async move {
1634                        let method = HealthCheckSvc(inner);
1635                        let codec = tonic_prost::ProstCodec::default();
1636                        let mut grpc = tonic::server::Grpc::new(codec)
1637                            .apply_compression_config(
1638                                accept_compression_encodings,
1639                                send_compression_encodings,
1640                            )
1641                            .apply_max_message_size_config(
1642                                max_decoding_message_size,
1643                                max_encoding_message_size,
1644                            );
1645                        let res = grpc.unary(method, req).await;
1646                        Ok(res)
1647                    };
1648                    Box::pin(fut)
1649                }
1650                "/vectorizer.VectorizerService/GetStats" => {
1651                    #[allow(non_camel_case_types)]
1652                    struct GetStatsSvc<T: VectorizerService>(pub Arc<T>);
1653                    impl<
1654                        T: VectorizerService,
1655                    > tonic::server::UnaryService<super::GetStatsRequest>
1656                    for GetStatsSvc<T> {
1657                        type Response = super::GetStatsResponse;
1658                        type Future = BoxFuture<
1659                            tonic::Response<Self::Response>,
1660                            tonic::Status,
1661                        >;
1662                        fn call(
1663                            &mut self,
1664                            request: tonic::Request<super::GetStatsRequest>,
1665                        ) -> Self::Future {
1666                            let inner = Arc::clone(&self.0);
1667                            let fut = async move {
1668                                <T as VectorizerService>::get_stats(&inner, request).await
1669                            };
1670                            Box::pin(fut)
1671                        }
1672                    }
1673                    let accept_compression_encodings = self.accept_compression_encodings;
1674                    let send_compression_encodings = self.send_compression_encodings;
1675                    let max_decoding_message_size = self.max_decoding_message_size;
1676                    let max_encoding_message_size = self.max_encoding_message_size;
1677                    let inner = self.inner.clone();
1678                    let fut = async move {
1679                        let method = GetStatsSvc(inner);
1680                        let codec = tonic_prost::ProstCodec::default();
1681                        let mut grpc = tonic::server::Grpc::new(codec)
1682                            .apply_compression_config(
1683                                accept_compression_encodings,
1684                                send_compression_encodings,
1685                            )
1686                            .apply_max_message_size_config(
1687                                max_decoding_message_size,
1688                                max_encoding_message_size,
1689                            );
1690                        let res = grpc.unary(method, req).await;
1691                        Ok(res)
1692                    };
1693                    Box::pin(fut)
1694                }
1695                _ => {
1696                    Box::pin(async move {
1697                        let mut response = http::Response::new(
1698                            tonic::body::Body::default(),
1699                        );
1700                        let headers = response.headers_mut();
1701                        headers
1702                            .insert(
1703                                tonic::Status::GRPC_STATUS,
1704                                (tonic::Code::Unimplemented as i32).into(),
1705                            );
1706                        headers
1707                            .insert(
1708                                http::header::CONTENT_TYPE,
1709                                tonic::metadata::GRPC_CONTENT_TYPE,
1710                            );
1711                        Ok(response)
1712                    })
1713                }
1714            }
1715        }
1716    }
1717    impl<T> Clone for VectorizerServiceServer<T> {
1718        fn clone(&self) -> Self {
1719            let inner = self.inner.clone();
1720            Self {
1721                inner,
1722                accept_compression_encodings: self.accept_compression_encodings,
1723                send_compression_encodings: self.send_compression_encodings,
1724                max_decoding_message_size: self.max_decoding_message_size,
1725                max_encoding_message_size: self.max_encoding_message_size,
1726            }
1727        }
1728    }
1729    /// Generated gRPC service name
1730    pub const SERVICE_NAME: &str = "vectorizer.VectorizerService";
1731    impl<T> tonic::server::NamedService for VectorizerServiceServer<T> {
1732        const NAME: &'static str = SERVICE_NAME;
1733    }
1734}