feat: support ext. api keys in header

Author: dancixx

src/external_api_keys.rs

@@ -0,0 +1,31 @@
+use std::collections::HashMap;
+
+use tonic::metadata::{MetadataKey, MetadataValue};
+use tonic::service::Interceptor;
+use tonic::{Request, Status};
+
+pub struct ExternalApiKeysInterceptor {
+    external_api_keys: Option<HashMap<String, String>>,
+}
+
+impl ExternalApiKeysInterceptor {
+    pub fn new(external_api_keys: Option<HashMap<String, String>>) -> Self {
+        Self { external_api_keys }
+    }
+}
+
+impl Interceptor for ExternalApiKeysInterceptor {
+    fn call(&mut self, mut request: Request<()>) -> anyhow::Result<Request<()>, Status> {
+        if let Some(ext_api_keys) = &self.external_api_keys {
+            for (k, v) in ext_api_keys {
+                let key = MetadataKey::from_bytes(k.as_bytes())
+                    .map_err(|_| Status::invalid_argument(format!("Invalid metadata key: {k}")))?;
+                let value = MetadataValue::try_from(v.as_str()).map_err(|_| {
+                    Status::invalid_argument(format!("Invalid metadata value for {k}: {v}"))
+                })?;
+                request.metadata_mut().insert(key, value);
+            }
+        }
+        Ok(request)
+    }
+}

src/lib.rs

@@ -138,6 +138,7 @@ mod builder_types;
 mod builders;
 mod channel_pool;
 mod expressions;
+mod external_api_keys;
 mod filters;
 mod grpc_conversions;
 mod grpc_macros;

src/qdrant_client/config.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::time::Duration;
 
 use crate::{Qdrant, QdrantError};
@@ -33,6 +34,9 @@ pub struct QdrantConfig {
     /// Optional API key or token to use for authorization
     pub api_key: Option<String>,
 
+    /// Optional API keys for external embedding providers (OpenAI, JINA, Cohere, OpenRouter)
+    pub external_api_keys: Option<HashMap<String, String>>,
+
     /// Optional compression schema to use for API requests
     pub compression: Option<CompressionEncoding>,
 
@@ -89,6 +93,22 @@ impl QdrantConfig {
         self
     }
 
+    /// Set an optional map of external API keys for embedding providers (OpenAI, JINA, Cohere, OpenRouter)
+    ///
+    /// # Examples
+    /// ```rust,no_run
+    ///# use std::collections::HashMap;
+    ///# let config: HashMap<&str, String> = HashMap::new();
+    ///# use qdrant_client::Qdrant;
+    /// let client = Qdrant::from_url("http://localhost:6334")
+    ///     .external_api_keys(config.get("external_api_keys"))
+    ///     .build();
+    /// ```
+    pub fn external_api_keys(mut self, external_api_keys: impl AsOptionExternalApiKeys) -> Self {
+        self.external_api_keys = external_api_keys.external_api_keys();
+        self
+    }
+
     /// Keep the connection alive while idle
     pub fn keep_alive_while_idle(mut self) -> Self {
         self.keep_alive_while_idle = true;
@@ -201,6 +221,7 @@ impl Default for QdrantConfig {
             connect_timeout: Duration::from_secs(5),
             keep_alive_while_idle: true,
             api_key: None,
+            external_api_keys: None,
             compression: None,
             check_compatibility: true,
             pool_size: 3,
@@ -303,3 +324,69 @@ impl<E: Sized> AsOptionApiKey for Result<String, E> {
         self.ok()
     }
 }
+
+/// Set an optional API key from various types
+///
+/// For example:
+///
+/// ```rust
+///# use std::time::Duration;
+///# use qdrant_client::Qdrant;
+///# let mut config = Qdrant::from_url("http://localhost:6334");
+/// config
+///     .external_api_keys(("openai-api-key", "<YOUR_OPENAI_API_KEY>"))
+///     .external_api_keys((String::from("openai-api-key"), String::from("<YOUR_OPENAI_API_KEY>")))
+///     .external_api_keys((String::from("openai-api-key").unwrap(), std::env::var("OPENAI_API_KEY").unwrap()));
+/// ```
+///
+/// /// ```rust
+///# use std::time::Duration;
+///# use qdrant_client::Qdrant;
+///# let mut config = Qdrant::from_url("http://localhost:6334");
+///# let ext_api_keys = HashMap::from([("openai-api-key", "<YOUR_OPENAI_API_KEY>"), ("cohere-api-key", "<YOUR_COHERE_API_KEY>")])
+/// config
+///     .external_api_keys(ext_api_keys);
+/// ```
+pub trait AsOptionExternalApiKeys {
+    fn external_api_keys(self) -> Option<HashMap<String, String>>;
+}
+
+impl<K, V> AsOptionExternalApiKeys for (K, V)
+where
+    K: Into<String>,
+    V: Into<String>,
+{
+    fn external_api_keys(self) -> Option<HashMap<String, String>> {
+        let (k, v) = self;
+        Some(HashMap::from([(k.into(), v.into())]))
+    }
+}
+
+impl<K, V> AsOptionExternalApiKeys for Option<(K, V)>
+where
+    K: Into<String>,
+    V: Into<String>,
+{
+    fn external_api_keys(self) -> Option<HashMap<String, String>> {
+        let (k, v) = self?;
+        Some(HashMap::from([(k.into(), v.into())]))
+    }
+}
+
+impl AsOptionExternalApiKeys for Option<HashMap<String, String>> {
+    fn external_api_keys(self) -> Option<HashMap<String, String>> {
+        self
+    }
+}
+
+impl AsOptionExternalApiKeys for HashMap<String, String> {
+    fn external_api_keys(self) -> Option<HashMap<String, String>> {
+        Some(self)
+    }
+}
+
+impl<E: Sized> AsOptionExternalApiKeys for Result<HashMap<String, String>, E> {
+    fn external_api_keys(self) -> Option<HashMap<String, String>> {
+        self.ok()
+    }
+}

src/qdrant_client/mod.rs

@@ -20,11 +20,12 @@ use tonic::codegen::InterceptedService;
 use tonic::transport::{Channel, Uri};
 use tonic::Status;
 
-use crate::auth::TokenInterceptor;
 use crate::channel_pool::ChannelPool;
 use crate::qdrant::{qdrant_client, HealthCheckReply, HealthCheckRequest};
 use crate::qdrant_client::config::QdrantConfig;
 use crate::qdrant_client::version_check::is_compatible;
+use crate::auth::TokenInterceptor;
+use crate::external_api_keys::ExternalApiKeysInterceptor;
 use crate::QdrantError;
 
 /// [`Qdrant`] client result
@@ -184,6 +185,15 @@ impl Qdrant {
         InterceptedService::new(channel, interceptor)
     }
 
+    /// Wraps a service with external API keys interceptor
+    fn with_external_api_keys<S>(
+        &self,
+        service: S,
+    ) -> InterceptedService<S, ExternalApiKeysInterceptor> {
+        let interceptor = ExternalApiKeysInterceptor::new(self.config.external_api_keys.clone());
+        InterceptedService::new(service, interceptor)
+    }
+
     // Access to raw root qdrant API
     async fn with_root_qdrant_client<T, O: Future<Output = Result<T, Status>>>(
         &self,

src/qdrant_client/points.rs

@@ -5,6 +5,7 @@ use tonic::transport::Channel;
 use tonic::Status;
 
 use crate::auth::TokenInterceptor;
+use crate::external_api_keys::ExternalApiKeysInterceptor;
 use crate::qdrant::points_client::PointsClient;
 use crate::qdrant::{
     CountPoints, CountResponse, DeletePointVectors, DeletePoints, FacetCounts, FacetResponse,
@@ -22,13 +23,21 @@ use crate::qdrant_client::{Qdrant, QdrantResult};
 impl Qdrant {
     pub(crate) async fn with_points_client<T, O: Future<Output = Result<T, Status>>>(
         &self,
-        f: impl Fn(PointsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            PointsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    ExternalApiKeysInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> QdrantResult<T> {
         let result = self
             .channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = self.with_external_api_keys(service);
                     let mut client =
                         PointsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.config.compression {