feat: Add Jina as a selectable embeddings provider with reranking support

This commit adds Jina AI as a new embeddings provider option with the following features:

- Added JinaEmbeddingProvider implementing the EmbeddingProvider trait
- Support for Jina embeddings API (jina-embeddings-v4 model)
- Configurable task parameter (default: code.query for code embeddings)
- Late chunking support enabled by default for improved accuracy
- Integrated reranking functionality using Jina reranker-v3 model
- Reranking is enabled by default when Jina provider is selected
- Added Jina variant to EmbeddingProvider enum
- Created JinaEmbeddingConfig struct with all necessary configuration options
- Added 'jina' feature flag to Cargo.toml
- Registered jina_provider module in lib.rs
- Updated example_embedding.toml with Jina configuration example

The implementation follows the same pattern as existing providers (OpenAI, Ollama)
with retry logic, batch processing, and proper error handling.

Author: claude

config/example_embedding.toml

@@ -14,6 +14,26 @@ api_base = "https://api.openai.com/v1"
 max_retries = 3
 timeout_secs = 30
 
+# Example Jina configuration (uncomment to use)
+# [embedding]
+# provider = "jina"
+# dimension = 1024
+# cache_enabled = true
+# cache_ttl_secs = 3600
+# normalize_embeddings = true
+#
+# [embedding.jina]
+# model = "jina-embeddings-v4"
+# api_key_env = "JINA_API_KEY"
+# api_base = "https://api.jina.ai/v1"
+# max_retries = 3
+# timeout_secs = 30
+# task = "code.query"
+# late_chunking = true
+# enable_reranking = true
+# reranking_model = "jina-reranker-v3"
+# reranking_top_n = 10
+
 [performance]
 mode = "balanced"
 

crates/codegraph-core/src/embedding_config.rs

@@ -10,6 +10,7 @@ pub enum EmbeddingProvider {
     Local,
     Cohere,
     HuggingFace,
+    Jina,
     Custom(String),
 }
 
@@ -95,6 +96,79 @@ impl Default for LocalEmbeddingConfig {
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct JinaEmbeddingConfig {
+    pub model: String,
+    pub api_key_env: String,
+    #[serde(default = "JinaEmbeddingConfig::default_api_base")]
+    pub api_base: String,
+    #[serde(default = "JinaEmbeddingConfig::default_max_retries")]
+    pub max_retries: u32,
+    #[serde(default = "JinaEmbeddingConfig::default_timeout_secs")]
+    pub timeout_secs: u64,
+    #[serde(default = "JinaEmbeddingConfig::default_task")]
+    pub task: String,
+    #[serde(default = "JinaEmbeddingConfig::default_late_chunking")]
+    pub late_chunking: bool,
+    #[serde(default = "JinaEmbeddingConfig::default_enable_reranking")]
+    pub enable_reranking: bool,
+    #[serde(default = "JinaEmbeddingConfig::default_reranking_model")]
+    pub reranking_model: String,
+    #[serde(default = "JinaEmbeddingConfig::default_reranking_top_n")]
+    pub reranking_top_n: usize,
+}
+
+impl JinaEmbeddingConfig {
+    fn default_api_base() -> String {
+        "https://api.jina.ai/v1".to_string()
+    }
+
+    fn default_max_retries() -> u32 {
+        3
+    }
+
+    fn default_timeout_secs() -> u64 {
+        30
+    }
+
+    fn default_task() -> String {
+        "code.query".to_string()
+    }
+
+    fn default_late_chunking() -> bool {
+        true
+    }
+
+    fn default_enable_reranking() -> bool {
+        true
+    }
+
+    fn default_reranking_model() -> String {
+        "jina-reranker-v3".to_string()
+    }
+
+    fn default_reranking_top_n() -> usize {
+        10
+    }
+}
+
+impl Default for JinaEmbeddingConfig {
+    fn default() -> Self {
+        Self {
+            model: "jina-embeddings-v4".to_string(),
+            api_key_env: "JINA_API_KEY".to_string(),
+            api_base: Self::default_api_base(),
+            max_retries: Self::default_max_retries(),
+            timeout_secs: Self::default_timeout_secs(),
+            task: Self::default_task(),
+            late_chunking: Self::default_late_chunking(),
+            enable_reranking: Self::default_enable_reranking(),
+            reranking_model: Self::default_reranking_model(),
+            reranking_top_n: Self::default_reranking_top_n(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct EmbeddingModelConfig {
     #[serde(default)]
@@ -109,6 +183,9 @@ pub struct EmbeddingModelConfig {
     #[serde(default)]
     pub local: Option<LocalEmbeddingConfig>,
 
+    #[serde(default)]
+    pub jina: Option<JinaEmbeddingConfig>,
+
     #[serde(default)]
     pub custom_config: HashMap<String, serde_json::Value>,
 
@@ -175,6 +252,22 @@ impl EmbeddingModelConfig {
                     anyhow::ensure!(config.batch_size > 0, "Batch size must be greater than 0");
                 }
             }
+            EmbeddingProvider::Jina => {
+                anyhow::ensure!(
+                    self.jina.is_some(),
+                    "Jina configuration required when using Jina provider"
+                );
+                if let Some(config) = &self.jina {
+                    anyhow::ensure!(
+                        !config.model.is_empty(),
+                        "Jina model name cannot be empty"
+                    );
+                    anyhow::ensure!(
+                        !config.api_key_env.is_empty(),
+                        "Jina API key environment variable name cannot be empty"
+                    );
+                }
+            }
             _ => {}
         }
 
@@ -190,6 +283,7 @@ impl EmbeddingModelConfig {
                 ..Default::default()
             }),
             local: None,
+            jina: None,
             custom_config: HashMap::new(),
             cache_enabled: Self::default_cache_enabled(),
             cache_ttl_secs: Self::default_cache_ttl_secs(),
@@ -206,6 +300,24 @@ impl EmbeddingModelConfig {
                 model_path: model_path.to_string(),
                 ..Default::default()
             }),
+            jina: None,
+            custom_config: HashMap::new(),
+            cache_enabled: Self::default_cache_enabled(),
+            cache_ttl_secs: Self::default_cache_ttl_secs(),
+            normalize_embeddings: Self::default_normalize_embeddings(),
+        }
+    }
+
+    pub fn for_jina(model: &str, dimension: usize) -> Self {
+        Self {
+            provider: EmbeddingProvider::Jina,
+            dimension,
+            openai: None,
+            local: None,
+            jina: Some(JinaEmbeddingConfig {
+                model: model.to_string(),
+                ..Default::default()
+            }),
             custom_config: HashMap::new(),
             cache_enabled: Self::default_cache_enabled(),
             cache_ttl_secs: Self::default_cache_ttl_secs(),
@@ -221,6 +333,7 @@ impl Default for EmbeddingModelConfig {
             dimension: Self::default_dimension(),
             openai: None,
             local: Some(LocalEmbeddingConfig::default()),
+            jina: None,
             custom_config: HashMap::new(),
             cache_enabled: Self::default_cache_enabled(),
             cache_ttl_secs: Self::default_cache_ttl_secs(),
@@ -277,13 +390,22 @@ impl EmbeddingPreset {
         }
     }
 
+    pub fn jina_v4() -> Self {
+        Self {
+            name: "jina-v4".to_string(),
+            description: "Jina embeddings-v4 model (multimodal, code-optimized with reranking)".to_string(),
+            config: EmbeddingModelConfig::for_jina("jina-embeddings-v4", 1024),
+        }
+    }
+
     pub fn all_presets() -> Vec<Self> {
         vec![
             Self::openai_small(),
             Self::openai_large(),
             Self::openai_ada(),
             Self::local_minilm(),
             Self::local_mpnet(),
+            Self::jina_v4(),
         ]
     }
 

crates/codegraph-vector/Cargo.toml

@@ -75,6 +75,7 @@ local-embeddings = [
 onnx = ["dep:ort", "dep:tokenizers", "dep:hf-hub", "dep:ndarray"]
 onnx-coreml = ["onnx"]
 ollama = ["dep:reqwest"]
+jina = ["dep:reqwest"]
 
 [[example]]
 name = "rag_demo"