fix: rust docs

Author: dancixx

src/external_api_keys.rs

@@ -18,6 +18,10 @@ 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 {
+                // Treat empty values as "missing key" (e.g. absent env var), so requests can proceed.
+                if v.trim().is_empty() {
+                    continue;
+                }
                 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(|_| {
@@ -103,4 +107,28 @@ mod tests {
         assert_eq!(error.code(), tonic::Code::InvalidArgument);
         assert!(error.message().contains("Invalid metadata value"));
     }
+
+    #[test]
+    fn skips_empty_external_api_key_values() {
+        let api_keys = HashMap::from([
+            ("openai-api-key".to_string(), "".to_string()),
+            ("cohere-api-key".to_string(), "cohere-secret".to_string()),
+        ]);
+
+        let mut interceptor = ExternalApiKeysInterceptor::new(Some(api_keys));
+        let request = interceptor
+            .call(Request::new(()))
+            .expect("interceptor must ignore empty external API key values");
+
+        assert!(request.metadata().get("openai-api-key").is_none());
+        assert_eq!(
+            request
+                .metadata()
+                .get("cohere-api-key")
+                .expect("cohere-api-key header must exist")
+                .to_str()
+                .expect("cohere-api-key header must be valid ASCII"),
+            "cohere-secret"
+        );
+    }
 }

src/qdrant_client/config.rs

@@ -98,10 +98,14 @@ impl QdrantConfig {
     /// # Examples
     /// ```rust,no_run
     ///# use std::collections::HashMap;
-    ///# let config: HashMap<&str, String> = HashMap::new();
+    ///# let mut config: HashMap<&str, HashMap<String, String>> = HashMap::new();
+    ///# config.insert(
+    ///#     "external_api_keys",
+    ///#     HashMap::from([("openai-api-key".to_string(), "<YOUR_OPENAI_API_KEY>".to_string())]),
+    ///# );
     ///# use qdrant_client::Qdrant;
     /// let client = Qdrant::from_url("http://localhost:6334")
-    ///     .external_api_keys(config.get("external_api_keys"))
+    ///     .external_api_keys(config.get("external_api_keys").cloned())
     ///     .build();
     /// ```
     pub fn external_api_keys(mut self, external_api_keys: impl AsOptionExternalApiKeys) -> Self {
@@ -325,25 +329,27 @@ impl<E: Sized> AsOptionApiKey for Result<String, E> {
     }
 }
 
-/// Set an optional API key from various types
+/// Set optional external API keys 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()));
+///     .external_api_keys((String::from("openai-api-key"), "<YOUR_OPENAI_API_KEY>".to_string()));
 /// ```
 ///
-/// /// ```rust
-///# use std::time::Duration;
+/// ```rust
+///# use std::collections::HashMap;
 ///# 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>")])
+///# let ext_api_keys = HashMap::from([
+///#     ("openai-api-key".to_string(), "<YOUR_OPENAI_API_KEY>".to_string()),
+///#     ("cohere-api-key".to_string(), "<YOUR_COHERE_API_KEY>".to_string()),
+///# ]);
 /// config
 ///     .external_api_keys(ext_api_keys);
 /// ```