Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
refactor(embedding): remove unused batch APIs (#3260)
Qin Haojieca70bc06491e
diff --git a/docs/design/local-embedding-llama-cpp-design.md b/docs/design/local-embedding-llama-cpp-design.mdindex c097dab4d..5e35ed55d 100644--- a/docs/design/local-embedding-llama-cpp-design.md+++ b/docs/design/local-embedding-llama-cpp-design.md@@ -335,21 +335,6 @@ OpenViking 当前在 client 启动时就初始化 embedder,本地方案保持- 本地 embedder 自动套用 query 侧规则- 检索时使用与 document 同体系生成的向量-## 批量 Embedding 策略--第一版可以先保证单条处理正确,但设计上必须明确批量优化路径。--阶段一:--- 在 `LocalDenseEmbedder` 中实现 `embed_batch()`-- 队列层暂时仍允许继续按单条处理--阶段二:--- 在队列侧做消息聚合,一次编码多条待 embedding 文本--如果没有批量能力,本地 CPU 索引构建吞吐大概率会明显低于模型 benchmark。-## 开发顺序1. 增加 `local` backend 的配置校验和 factory 注册。@@ -360,8 +345,7 @@ OpenViking 当前在 client 启动时就初始化 embedder,本地方案保持6. 增加 `embed_query()` / `embed_document()` 双路接口。7. 持久化 collection embedding 元数据,并补一致性检查。8. 增加 rebuild-required 错误流。-9. 增加 `embed_batch()` 和 benchmark 基础设施。-10. 更新用户文档、示例配置和安装说明。+9. 更新用户文档、示例配置和安装说明。## 测试计划@@ -383,7 +367,6 @@ OpenViking 当前在 client 启动时就初始化 embedder,本地方案保持- `embed_query()` 与 `embed_document()` 走不同路径- 返回维度与模型维度一致-- `embed_batch()` 的结果顺序和数量正确### 元数据与重建测试diff --git a/openviking/models/embedder/base.py b/openviking/models/embedder/base.pyindex 61efef88f..8138c1548 100644--- a/openviking/models/embedder/base.py+++ b/openviking/models/embedder/base.py@@ -94,18 +94,6 @@ async def embed_compat(return await embedder.embed_async(embedding_input, is_query=is_query)-async def embed_batch_compat(- embedder: "EmbedderBase", texts: List[str], *, is_query: bool = False-) -> List["EmbedResult"]:- """Prepare inputs, then call the embedder's async-compatible batch entrypoint."""- from openviking.telemetry import bind_telemetry_stage-- stage = "embed_query" if is_query else "embed_resource"- embedding_inputs = embedder.prepare_embedding_inputs(texts)- with bind_telemetry_stage(stage):- return await embedder.embed_batch_async(embedding_inputs, is_query=is_query)--def truncate_and_normalize(embedding: List[float], dimension: Optional[int]) -> List[float]:"""Truncate and L2 normalize embedding vector@@ -208,10 +196,6 @@ class EmbedderBase(ABC):return contentreturn truncate_embedding_input(content, self.max_input_tokens)- def prepare_embedding_inputs(self, contents: List["EmbeddingInput"]) -> List["EmbeddingInput"]:- """Apply this embedder's input guard to a batch."""- return [self.prepare_embedding_input(content) for content in contents]-@propertydef supports_multimodal(self) -> bool:"""Whether this embedder can consume multimodal (image) inputs directly.@@ -235,36 +219,10 @@ class EmbedderBase(ABC):"""pass- def embed_batch(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Batch embedding (default implementation loops, subclasses can override for optimization)-- Args:- contents: List of texts or multimodal content parts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results- """- return [self.embed(content, is_query=is_query) for content in contents]-def embed_query(self, text: str) -> EmbedResult:"""Embed query text with explicit retrieval-side semantics."""return self.embed(text, is_query=True)- def embed_document(self, text: str) -> EmbedResult:- """Embed document text with explicit indexing-side semantics."""- return self.embed(text, is_query=False)-- def embed_batch_query(self, texts: List[str]) -> List[EmbedResult]:- """Batch embed query texts."""- return self.embed_batch(texts, is_query=True)-- def embed_batch_document(self, texts: List[str]) -> List[EmbedResult]:- """Batch embed document texts."""- return self.embed_batch(texts, is_query=False)-async def embed_async(self, content: "EmbeddingInput", is_query: bool = False) -> EmbedResult:"""Async embed text or multimodal content.@@ -274,27 +232,9 @@ class EmbedderBase(ABC):"""return self.embed(content, is_query=is_query)- async def embed_batch_async(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Async batch embedding."""- results: List[EmbedResult] = []- for content in contents:- results.append(await self.embed_async(content, is_query=is_query))- return results-async def embed_query_async(self, text: str) -> EmbedResult:return await self.embed_async(text, is_query=True)- async def embed_document_async(self, text: str) -> EmbedResult:- return await self.embed_async(text, is_query=False)-- async def embed_batch_query_async(self, texts: List[str]) -> List[EmbedResult]:- return await self.embed_batch_async(texts, is_query=True)-- async def embed_batch_document_async(self, texts: List[str]) -> List[EmbedResult]:- return await self.embed_batch_async(texts, is_query=False)-def close(self):"""Release resources, subclasses can override as needed"""pass@@ -601,20 +541,6 @@ class CompositeHybridEmbedder(HybridEmbedderBase):dense_vector=dense_res.dense_vector, sparse_vector=sparse_res.sparse_vector)- def embed_batch(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Combine batch results"""- dense_inputs = self.dense_embedder.prepare_embedding_inputs(contents)- sparse_inputs = self.sparse_embedder.prepare_embedding_inputs(contents)- dense_results = self.dense_embedder.embed_batch(dense_inputs, is_query=is_query)- sparse_results = self.sparse_embedder.embed_batch(sparse_inputs, is_query=is_query)-- return [- EmbedResult(dense_vector=d.dense_vector, sparse_vector=s.sparse_vector)- for d, s in zip(dense_results, sparse_results, strict=True)- ]-async def embed_async(self, content: "EmbeddingInput", is_query: bool = False) -> EmbedResult:dense_input = self.dense_embedder.prepare_embedding_input(content)sparse_input = self.sparse_embedder.prepare_embedding_input(content)@@ -626,20 +552,6 @@ class CompositeHybridEmbedder(HybridEmbedderBase):dense_vector=dense_res.dense_vector, sparse_vector=sparse_res.sparse_vector)- async def embed_batch_async(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- dense_inputs = self.dense_embedder.prepare_embedding_inputs(contents)- sparse_inputs = self.sparse_embedder.prepare_embedding_inputs(contents)- dense_results, sparse_results = await asyncio.gather(- self.dense_embedder.embed_batch_async(dense_inputs, is_query=is_query),- self.sparse_embedder.embed_batch_async(sparse_inputs, is_query=is_query),- )- return [- EmbedResult(dense_vector=d.dense_vector, sparse_vector=s.sparse_vector)- for d, s in zip(dense_results, sparse_results, strict=True)- ]-def get_dimension(self) -> int:return self.dense_embedder.get_dimension()@@ -871,24 +783,10 @@ class FailoverEmbedder(EmbedderBase):"""Embed text or multimodal content with multi-credential failover support."""return self._embed_with_failover("embed", content, is_query=is_query)- def embed_batch(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Batch embed with multi-credential failover support."""- return self._embed_with_failover("embed_batch", contents, is_query=is_query)-async def embed_async(self, content: "EmbeddingInput", is_query: bool = False) -> EmbedResult:"""Async embed with multi-credential failover support."""return await self._embed_with_failover_async("embed_async", content, is_query=is_query)- async def embed_batch_async(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Async batch embed with multi-credential failover support."""- return await self._embed_with_failover_async(- "embed_batch_async", contents, is_query=is_query- )-def get_dimension(self) -> int:"""Get the dense dimension from the first embedder.diff --git a/openviking/models/embedder/cohere_embedders.py b/openviking/models/embedder/cohere_embedders.pyindex d64270a84..f31e676c6 100644--- a/openviking/models/embedder/cohere_embedders.py+++ b/openviking/models/embedder/cohere_embedders.py@@ -181,69 +181,6 @@ class CohereDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"Cohere embedding failed: {e}") from e- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- if not texts:- return []- input_type = "search_query" if is_query else "search_document"- try:- results: List[EmbedResult] = []- for i in range(0, len(texts), 96):- batch = texts[i : i + 96]- vectors = self._call_api(batch, input_type)- results.extend(EmbedResult(dense_vector=self._normalize_vector(v)) for v in vectors)- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="cohere",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results- except httpx.HTTPStatusError as e:- raise RuntimeError(- f"Cohere API error: {e.response.status_code} {e.response.text}"- ) from e- except Exception as e:- raise RuntimeError(f"Cohere batch embedding failed: {e}") from e-- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- input_type = "search_query" if is_query else "search_document"-- async def _call() -> List[EmbedResult]:- results: List[EmbedResult] = []- for i in range(0, len(texts), 96):- batch = texts[i : i + 96]- vectors = await self._call_api_async(batch, input_type)- results.extend(EmbedResult(dense_vector=self._normalize_vector(v)) for v in vectors)- return results-- try:- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="Cohere async batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="cohere",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results- except httpx.HTTPStatusError as e:- raise RuntimeError(- f"Cohere API error: {e.response.status_code} {e.response.text}"- ) from e- except Exception as e:- raise RuntimeError(f"Cohere batch embedding failed: {e}") from e-def close(self):"""Close the httpx client connection pool."""self._client.close()diff --git a/openviking/models/embedder/dashscope_embedders.py b/openviking/models/embedder/dashscope_embedders.pyindex 972e718c2..1d276d8ff 100644--- a/openviking/models/embedder/dashscope_embedders.py+++ b/openviking/models/embedder/dashscope_embedders.py@@ -246,102 +246,6 @@ class DashScopeDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"DashScope embedding failed: {e}") from e- # ------------------------------------------------------------------- # embed_batch — text mode chunks by 10 (DashScope text API limit)- # -------------------------------------------------------------------- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- if not texts:- return []-- def _call() -> List[EmbedResult]:- results: List[EmbedResult] = []- if self._input_type == "text":- for i in range(0, len(texts), 10):- batch = texts[i : i + 10]- response = self._openai_client.embeddings.create(- input=batch, model=self.model_name, dimensions=self._dimension- )- self._update_telemetry_token_usage(response)- for item in response.data:- results.append(- EmbedResult(- dense_vector=truncate_and_normalize(item.embedding, self._dimension)- )- )- else:- for text in texts:- resp = self._httpx_client.post(- self._multimodal_url, json=self._multimodal_body(text)- )- resp.raise_for_status()- self._update_telemetry_token_usage(resp)- vector = resp.json()["output"]["embeddings"][0]["embedding"]- results.append(- EmbedResult(dense_vector=truncate_and_normalize(vector, self._dimension))- )- return results-- try:- return self._run_with_retry(- _call, logger=logger, operation_name="DashScope batch embedding"- )- except Exception as e:- logger.error(- f"DashScope batch embedding failed, texts length: {len(texts)}, "- f"input_type: {self._input_type}, model_name: {self.model_name}"- )- raise RuntimeError(f"DashScope batch embedding failed: {e}") from e-- # ------------------------------------------------------------------- # embed_batch_async- # -------------------------------------------------------------------- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- async def _call() -> List[EmbedResult]:- results: List[EmbedResult] = []- if self._input_type == "text":- client = self._get_async_openai_client()- for i in range(0, len(texts), 10):- batch = texts[i : i + 10]- response = await client.embeddings.create(- input=batch, model=self.model_name, dimensions=self._dimension- )- self._update_telemetry_token_usage(response)- for item in response.data:- results.append(- EmbedResult(- dense_vector=truncate_and_normalize(item.embedding, self._dimension)- )- )- else:- client = self._get_async_httpx_client()- for text in texts:- resp = await client.post(self._multimodal_url, json=self._multimodal_body(text))- resp.raise_for_status()- self._update_telemetry_token_usage(resp)- vector = resp.json()["output"]["embeddings"][0]["embedding"]- results.append(- EmbedResult(dense_vector=truncate_and_normalize(vector, self._dimension))- )- return results-- try:- return await self._run_with_async_retry(- _call, logger=logger, operation_name="DashScope async batch embedding"- )- except Exception as e:- logger.error(- f"DashScope async batch embedding failed, texts length: {len(texts)}, "- f"input_type: {self._input_type}, model_name: {self.model_name}"- )- raise RuntimeError(f"DashScope batch embedding failed: {e}") from e-# ------------------------------------------------------------------# embed_content — multimodal content (text + image URLs)# ------------------------------------------------------------------diff --git a/openviking/models/embedder/gemini_embedders.py b/openviking/models/embedder/gemini_embedders.pyindex c6ac23d7d..f962792fa 100644--- a/openviking/models/embedder/gemini_embedders.py+++ b/openviking/models/embedder/gemini_embedders.py@@ -2,8 +2,7 @@# SPDX-License-Identifier: AGPL-3.0"""Gemini Embedding 2 provider using the official google-genai SDK."""-import asyncio-from typing import Any, Dict, List, Optional+from typing import Any, Dict, Optionalfrom google import genaifrom google.genai import types@@ -25,8 +24,6 @@ from openviking_cli.utils import get_loggerlogger = get_logger(__name__)-_TEXT_BATCH_SIZE = 100-# Keep for backward-compat with existing unit tests that import it_GEMINI_INPUT_TOKEN_LIMIT = 8192 # gemini-embedding-2-preview hard limit@@ -126,7 +123,6 @@ class GeminiDenseEmbedder(DenseEmbedderBase):task_type: Optional[str] = None,query_param: Optional[str] = None,document_param: Optional[str] = None,- max_concurrent_batches: int = 10,config: Optional[Dict[str, Any]] = None,):super().__init__(model_name, config)@@ -159,7 +155,6 @@ class GeminiDenseEmbedder(DenseEmbedderBase):self.document_param = document_paramself._dimension = dimension or self._default_dimension(model_name)self._token_limit = _MODEL_TOKEN_LIMITS.get(model_name, _DEFAULT_TOKEN_LIMIT)- self._max_concurrent_batches = max_concurrent_batchesdef _build_config(self,@@ -282,162 +277,6 @@ class GeminiDenseEmbedder(DenseEmbedderBase):except (APIError, ClientError) as e:_raise_api_error(e, self.model_name)- def embed_batch(- self,- texts: List[str],- is_query: bool = False,- *,- task_type: Optional[str] = None,- titles: Optional[List[str]] = None,- ) -> List[EmbedResult]:- if not texts:- return []- # When titles are provided, delegate per-item (titles are per-document metadata).- if titles is not None:- return [- self.embed(text, is_query=is_query, task_type=task_type, title=title)- for text, title in zip(texts, titles, strict=True)- ]- task_type = self._resolve_task_type(is_query=is_query, task_type=task_type)- results: List[EmbedResult] = []- config = self._build_config(task_type=task_type)- for i in range(0, len(texts), _TEXT_BATCH_SIZE):- batch = texts[i : i + _TEXT_BATCH_SIZE]- non_empty_indices = [j for j, t in enumerate(batch) if t and t.strip()]- empty_indices = [j for j, t in enumerate(batch) if not (t and t.strip())]-- if not non_empty_indices:- results.extend(EmbedResult(dense_vector=[0.0] * self._dimension) for _ in batch)- continue-- non_empty_texts = [batch[j] for j in non_empty_indices]-- def _call_batch(- non_empty_texts: List[str] = non_empty_texts,- config: types.EmbedContentConfig = config,- ) -> Any:- response = self.client.models.embed_content(- model=self.model_name,- contents=non_empty_texts,- config=config,- )- return response-- try:- if _HTTP_RETRY_AVAILABLE:- response = _call_batch()- else:- response = self._run_with_retry(- _call_batch,- logger=logger,- operation_name="Gemini batch embedding",- )- batch_results = [None] * len(batch)- for j, emb in zip(non_empty_indices, response.embeddings, strict=True):- batch_results[j] = EmbedResult(- dense_vector=truncate_and_normalize(list(emb.values), self._dimension)- )- for j in empty_indices:- batch_results[j] = EmbedResult(dense_vector=[0.0] * self._dimension)- results.extend(batch_results)- except (APIError, ClientError) as e:- logger.warning(- "Gemini batch embed failed (HTTP %d) for batch of %d, falling back to individual",- e.code,- len(batch),- )- for text in batch:- results.append(self.embed(text, is_query=is_query))- # Token usage is already tracked via individual embed() calls- # No need to track here to avoid double counting- return results-- async def embed_batch_async(- self,- texts: List[str],- is_query: bool = False,- *,- task_type: Optional[str] = None,- titles: Optional[List[str]] = None,- ) -> List[EmbedResult]:- if not texts:- return []- if titles is not None:- return [- await self.embed_async(- text,- is_query=is_query,- task_type=task_type,- title=title,- )- for text, title in zip(texts, titles, strict=True)- ]-- task_type = self._resolve_task_type(is_query=is_query, task_type=task_type)- batches = [texts[i : i + _TEXT_BATCH_SIZE] for i in range(0, len(texts), _TEXT_BATCH_SIZE)]- results: List[Optional[List[EmbedResult]]] = [None] * len(batches)- sem = asyncio.Semaphore(self._max_concurrent_batches)-- async def _embed_one(idx: int, batch: List[str]) -> None:- async with sem:- non_empty_indices = [j for j, t in enumerate(batch) if t and t.strip()]- empty_indices = [j for j, t in enumerate(batch) if not (t and t.strip())]- batch_results: List[Optional[EmbedResult]] = [None] * len(batch)- for j in empty_indices:- batch_results[j] = EmbedResult(dense_vector=[0.0] * self._dimension)-- if not non_empty_indices:- results[idx] = [r for r in batch_results if r is not None]- return-- non_empty_texts = [batch[j] for j in non_empty_indices]-- async def _call_batch() -> Any:- return await self.client.aio.models.embed_content(- model=self.model_name,- contents=non_empty_texts,- config=self._build_config(task_type=task_type),- )-- try:- response = await self._run_with_async_retry(- _call_batch,- logger=logger,- operation_name="Gemini async batch embedding",- )- for j, emb in zip(non_empty_indices, response.embeddings, strict=True):- batch_results[j] = EmbedResult(- dense_vector=truncate_and_normalize(list(emb.values), self._dimension)- )- total_tokens = sum(self._estimate_tokens(text) for text in non_empty_texts)- self.update_token_usage(- model_name=self.model_name,- provider="gemini",- prompt_tokens=total_tokens,- completion_tokens=0,- )- except (APIError, ClientError) as e:- logger.warning(- "Gemini async batch embed failed (HTTP %d) for batch of %d, falling back to per-item async calls",- e.code,- len(batch),- )- for j in non_empty_indices:- batch_results[j] = await self.embed_async(- batch[j],- is_query=is_query,- task_type=task_type,- )-- results[idx] = [r for r in batch_results if r is not None]-- await asyncio.gather(*(_embed_one(idx, batch) for idx, batch in enumerate(batches)))- return [r for batch_results in results for r in (batch_results or [])]-- async def async_embed_batch(self, texts: List[str]) -> List[EmbedResult]:- """Backward-compatible alias for the standardized async batch API."""- return await self.embed_batch_async(texts)-def get_dimension(self) -> int:return self._dimensiondiff --git a/openviking/models/embedder/jina_embedders.py b/openviking/models/embedder/jina_embedders.pyindex 1283e3ef8..2d2897ab6 100644--- a/openviking/models/embedder/jina_embedders.py+++ b/openviking/models/embedder/jina_embedders.py@@ -244,82 +244,6 @@ class JinaDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"Embedding failed: {str(e)}") from e- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- """Batch embedding (Jina native support)-- Args:- texts: List of texts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results-- Raises:- RuntimeError: When API call fails- """- if not texts:- return []-- def _call() -> List[EmbedResult]:- response = self.client.embeddings.create(**self._build_kwargs(texts, is_query=is_query))-- return [EmbedResult(dense_vector=item.embedding) for item in response.data]-- try:- results = self._run_with_retry(- _call,- logger=logger,- operation_name="Jina batch embedding",- )- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="jina",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results- except openai.APIError as e:- self._raise_task_error(e)- raise RuntimeError(f"Jina API error: {e.message}") from e- except Exception as e:- raise RuntimeError(f"Batch embedding failed: {str(e)}") from e-- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- client = self._get_async_client()-- async def _call() -> List[EmbedResult]:- response = await client.embeddings.create(- **self._build_kwargs(texts, is_query=is_query)- )- return [EmbedResult(dense_vector=item.embedding) for item in response.data]-- try:- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="Jina async batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="jina",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results- except openai.APIError as e:- self._raise_task_error(e)- raise RuntimeError(f"Jina API error: {e.message}") from e- except Exception as e:- raise RuntimeError(f"Batch embedding failed: {str(e)}") from e-def get_dimension(self) -> int:"""Get embedding dimensiondiff --git a/openviking/models/embedder/litellm_embedders.py b/openviking/models/embedder/litellm_embedders.pyindex 7e63919f3..f62b86a02 100644--- a/openviking/models/embedder/litellm_embedders.py+++ b/openviking/models/embedder/litellm_embedders.py@@ -217,64 +217,6 @@ class LiteLLMDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"LiteLLM embedding failed: {e}") from e- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- """Batch embedding via litellm.-- Args:- texts: List of texts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results-- Raises:- RuntimeError: When embedding call fails- """- if not texts:- return []-- def _call() -> List[EmbedResult]:- kwargs = self._build_kwargs(is_query=is_query)- kwargs["input"] = texts- response = litellm.embedding(**kwargs)- self._update_telemetry_token_usage(response)- # Truncate vectors if needed- return [- EmbedResult(dense_vector=self._truncate_vector(item["embedding"]))- for item in response.data- ]-- try:- return self._run_with_retry(- _call,- logger=logger,- operation_name="LiteLLM batch embedding",- )- except Exception as e:- raise RuntimeError(f"LiteLLM batch embedding failed: {e}") from e-- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- async def _call() -> List[EmbedResult]:- kwargs = self._build_kwargs(is_query=is_query)- kwargs["input"] = texts- response = await litellm.aembedding(**kwargs)- self._update_telemetry_token_usage(response)- return [EmbedResult(dense_vector=item["embedding"]) for item in response.data]-- try:- return await self._run_with_async_retry(- _call,- logger=logger,- operation_name="LiteLLM async batch embedding",- )- except Exception as e:- raise RuntimeError(f"LiteLLM batch embedding failed: {e}") from e-def get_dimension(self) -> int:"""Get embedding dimension.diff --git a/openviking/models/embedder/local_embedders.py b/openviking/models/embedder/local_embedders.pyindex 395fde5eb..5d6819645 100644--- a/openviking/models/embedder/local_embedders.py+++ b/openviking/models/embedder/local_embedders.py@@ -178,11 +178,6 @@ class LocalDenseEmbedder(DenseEmbedderBase):return f"{self.query_instruction}{text}"return text- def _supports_native_batch_embeddings(self) -> bool:- context_params = getattr(self._llama, "context_params", None)- n_seq_max = getattr(context_params, "n_seq_max", 1)- return n_seq_max > 1-@staticmethoddef _extract_embedding(payload: Any) -> List[float]:if isinstance(payload, dict):@@ -195,35 +190,10 @@ class LocalDenseEmbedder(DenseEmbedderBase):return list(payload["embedding"])raise RuntimeError("Unexpected llama-cpp-python embedding response format")- @staticmethod- def _extract_embeddings(payload: Any) -> List[List[float]]:- if isinstance(payload, dict):- data = payload.get("data")- if isinstance(data, list):- vectors: List[List[float]] = []- for item in data:- if not isinstance(item, dict) or "embedding" not in item:- raise RuntimeError(- "Unexpected llama-cpp-python batch embedding response format"- )- vectors.append(list(item["embedding"]))- return vectors- raise RuntimeError("Unexpected llama-cpp-python batch embedding response format")-def _embed_formatted_text(self, formatted: str) -> EmbedResult:payload = self._llama.create_embedding(formatted)return EmbedResult(dense_vector=self._extract_embedding(payload))- def _embed_formatted_texts_sequential(self, formatted: List[str]) -> List[EmbedResult]:- return [- self._run_with_retry(- lambda formatted_text=text: self._embed_formatted_text(formatted_text),- logger=logger,- operation_name="local sequential batch embedding",- )- for text in formatted- ]-def embed(self, text: str, is_query: bool = False) -> EmbedResult:formatted = self._format_text(text, is_query=is_query)@@ -245,59 +215,6 @@ class LocalDenseEmbedder(DenseEmbedderBase):)return result- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- if not texts:- return []-- formatted = [self._format_text(text, is_query=is_query) for text in texts]- if len(formatted) > 1 and not self._supports_native_batch_embeddings():- logger.info(- "Local model %s does not support native multi-sequence batch embedding "- "(n_seq_max <= 1); using sequential mode",- self.model_name,- )- results = self._embed_formatted_texts_sequential(formatted)- estimated_tokens = sum(self._estimate_tokens(text) for text in formatted)- self.update_token_usage(- model_name=self.model_name,- provider="local",- prompt_tokens=estimated_tokens,- completion_tokens=0,- )- return results-- def _call_batch() -> List[EmbedResult]:- payload = self._llama.create_embedding(formatted)- return [- EmbedResult(dense_vector=vector) for vector in self._extract_embeddings(payload)- ]-- try:- results = self._run_with_retry(- _call_batch,- logger=logger,- operation_name="local batch embedding",- )- except Exception as batch_exc:- logger.warning(- "Local batch embedding failed for model=%s (%s); falling back to sequential embedding",- self.model_name,- batch_exc,- )- try:- results = self._embed_formatted_texts_sequential(formatted)- except Exception as exc:- raise RuntimeError(f"Local batch embedding failed: {exc}") from exc-- estimated_tokens = sum(self._estimate_tokens(text) for text in formatted)- self.update_token_usage(- model_name=self.model_name,- provider="local",- prompt_tokens=estimated_tokens,- completion_tokens=0,- )- return results-def get_dimension(self) -> int:return self._dimensiondiff --git a/openviking/models/embedder/minimax_embedders.py b/openviking/models/embedder/minimax_embedders.pyindex af5988e90..f9ce0b624 100644--- a/openviking/models/embedder/minimax_embedders.py+++ b/openviking/models/embedder/minimax_embedders.py@@ -231,49 +231,6 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):)return result- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- """Batch embedding"""- if not texts:- return []-- # MiniMax might have batch size limits, but let's assume the caller handles batching or use safe defaults- # For now, we pass through. If needed, we can implement internal chunking.- vectors = self._call_api(texts, is_query=is_query)- results = [EmbedResult(dense_vector=v) for v in vectors]- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="minimax",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- async def _call() -> List[EmbedResult]:- vectors = await self._call_api_async(texts, is_query=is_query)- return [EmbedResult(dense_vector=v) for v in vectors]-- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="MiniMax async batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="minimax",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-def get_dimension(self) -> int:"""Get embedding dimension"""return self._dimensiondiff --git a/openviking/models/embedder/openai_embedders.py b/openviking/models/embedder/openai_embedders.pyindex 5d79ca817..5b9f1c382 100644--- a/openviking/models/embedder/openai_embedders.py+++ b/openviking/models/embedder/openai_embedders.py@@ -345,72 +345,6 @@ class OpenAIDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"Embedding failed: {str(e)}") from e- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- """Batch embedding (OpenAI native support)-- Args:- texts: List of texts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results-- Raises:- RuntimeError: When API call fails- """- if not texts:- return []-- def _call() -> List[EmbedResult]:- response = self.client.embeddings.create(**self._build_kwargs(texts, is_query=is_query))- self._update_telemetry_token_usage(response)-- # Truncate vectors if needed- return [- EmbedResult(dense_vector=self._truncate_vector(item.embedding))- for item in response.data- ]-- try:- return self._run_with_retry(- _call,- logger=logger,- operation_name="OpenAI batch embedding",- )- except openai.APIError as e:- raise RuntimeError(f"OpenAI API error: {e.message}") from e- except Exception as e:- raise RuntimeError(f"Batch embedding failed: {str(e)}") from e-- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- client = self._get_async_client()-- async def _call() -> List[EmbedResult]:- response = await client.embeddings.create(- **self._build_kwargs(texts, is_query=is_query)- )- self._update_telemetry_token_usage(response)- return [- EmbedResult(dense_vector=self._truncate_vector(item.embedding))- for item in response.data- ]-- try:- return await self._run_with_async_retry(- _call,- logger=logger,- operation_name="OpenAI async batch embedding",- )- except openai.APIError as e:- raise RuntimeError(f"OpenAI API error: {e.message}") from e- except Exception as e:- raise RuntimeError(f"Batch embedding failed: {str(e)}") from e-def get_dimension(self) -> int:"""Get embedding dimensiondiff --git a/openviking/models/embedder/vikingdb_embedders.py b/openviking/models/embedder/vikingdb_embedders.pyindex c6f1901f2..5feff642b 100644--- a/openviking/models/embedder/vikingdb_embedders.py+++ b/openviking/models/embedder/vikingdb_embedders.py@@ -212,37 +212,6 @@ class VikingDBDenseEmbedder(DenseEmbedderBase, VikingDBClientMixin):)return result- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- if not texts:- return []- input_type = self._resolve_input_type(is_query)-- def _call() -> List[EmbedResult]:- raw_results = self._call_api(texts, dense_model=self.dense_model, input_type=input_type)- return [- EmbedResult(- dense_vector=self._truncate_and_normalize(- item.get("dense_embedding", []), self.dimension- )- )- for item in raw_results- ]-- results = self._run_with_retry(- _call,- logger=logger,- operation_name="VikingDB batch embedding",- )- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="volcengine",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-async def embed_async(self, text: str, is_query: bool = False) -> EmbedResult:async def _call() -> EmbedResult:results = await self._call_api_async([text], dense_model=self.dense_model)@@ -269,37 +238,6 @@ class VikingDBDenseEmbedder(DenseEmbedderBase, VikingDBClientMixin):)return result- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- async def _call() -> List[EmbedResult]:- raw_results = await self._call_api_async(texts, dense_model=self.dense_model)- return [- EmbedResult(- dense_vector=self._truncate_and_normalize(- item.get("dense_embedding", []), self.dimension- )- )- for item in raw_results- ]-- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="VikingDB async batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="volcengine",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-def get_dimension(self) -> int:return self.dimension if self.dimension else 2048@@ -354,34 +292,6 @@ class VikingDBSparseEmbedder(SparseEmbedderBase, VikingDBClientMixin):)return result- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- if not texts:- return []-- def _call() -> List[EmbedResult]:- raw_results = self._call_api(texts, sparse_model=self.sparse_model)- return [- EmbedResult(- sparse_vector=self._process_sparse_embedding(item.get("sparse_embedding", {}))- )- for item in raw_results- ]-- results = self._run_with_retry(- _call,- logger=logger,- operation_name="VikingDB sparse batch embedding",- )- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="volcengine",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-async def embed_async(self, text: str, is_query: bool = False) -> EmbedResult:async def _call() -> EmbedResult:results = await self._call_api_async([text], sparse_model=self.sparse_model)@@ -410,37 +320,6 @@ class VikingDBSparseEmbedder(SparseEmbedderBase, VikingDBClientMixin):)return result- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- async def _call() -> List[EmbedResult]:- raw_results = await self._call_api_async(texts, sparse_model=self.sparse_model)- return [- EmbedResult(- sparse_vector=self._process_sparse_embedding(- item.get("sparse_embedding", item.get("sparse", {}))- )- )- for item in raw_results- ]-- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="VikingDB async sparse batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="volcengine",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):"""VikingDB Hybrid Embedder"""@@ -519,44 +398,6 @@ class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):)return result- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- if not texts:- return []- input_type = self._resolve_input_type(is_query)-- def _call() -> List[EmbedResult]:- raw_results = self._call_api(- texts,- dense_model=self.dense_model,- sparse_model=self.sparse_model,- input_type=input_type,- )- results = []- for item in raw_results:- dense_vector = []- sparse_vector = {}- if "dense" in item:- dense_vector = self._truncate_and_normalize(item["dense"], self.dimension)- if "sparse" in item:- sparse_vector = item["sparse"]- results.append(EmbedResult(dense_vector=dense_vector, sparse_vector=sparse_vector))- return results-- results = self._run_with_retry(- _call,- logger=logger,- operation_name="VikingDB hybrid batch embedding",- )- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="volcengine",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-async def embed_async(self, text: str, is_query: bool = False) -> EmbedResult:async def _call() -> EmbedResult:results = await self._call_api_async(@@ -592,47 +433,6 @@ class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):)return result- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- async def _call() -> List[EmbedResult]:- raw_results = await self._call_api_async(- texts, dense_model=self.dense_model, sparse_model=self.sparse_model- )- results = []- for item in raw_results:- dense_vector = []- sparse_vector = {}- if "dense" in item:- dense_vector = self._truncate_and_normalize(item["dense"], self.dimension)- elif "dense_embedding" in item:- dense_vector = self._truncate_and_normalize(- item["dense_embedding"], self.dimension- )- if "sparse" in item:- sparse_vector = item["sparse"]- elif "sparse_embedding" in item:- sparse_vector = self._process_sparse_embedding(item["sparse_embedding"])- results.append(EmbedResult(dense_vector=dense_vector, sparse_vector=sparse_vector))- return results-- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="VikingDB async hybrid batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="volcengine",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results-def get_dimension(self) -> int:return self.dimension if self.dimension else 2048diff --git a/openviking/models/embedder/volcengine_embedders.py b/openviking/models/embedder/volcengine_embedders.pyindex 78530dc56..1f6d74d82 100644--- a/openviking/models/embedder/volcengine_embedders.py+++ b/openviking/models/embedder/volcengine_embedders.py@@ -2,7 +2,6 @@# SPDX-License-Identifier: AGPL-3.0"""Volcengine Embedder Implementation"""-import asynciofrom typing import Any, Dict, List, Optionalimport volcenginesdkarkruntime@@ -260,38 +259,6 @@ class VolcengineDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"Volcengine embedding failed: {str(e)}") from e- def embed_batch(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Batch embedding-- Args:- contents: List of texts or multimodal content parts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results-- Raises:- RuntimeError: When API call fails- """- if not contents:- return []- return [self.embed(content, is_query=is_query) for content in contents]-- async def embed_batch_async(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- if not contents:- return []-- # Embed each content individually and run them concurrently.- return list(- await asyncio.gather(- *(self.embed_async(content, is_query=is_query) for content in contents)- )- )-def get_dimension(self) -> int:return self._dimension@@ -436,39 +403,6 @@ class VolcengineSparseEmbedder(SparseEmbedderBase):except Exception as e:raise RuntimeError(f"Volcengine sparse embedding failed: {str(e)}") from e- def embed_batch(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Batch sparse embedding-- Args:- contents: List of texts or multimodal content parts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results-- Raises:- RuntimeError: When API call fails- """- if not contents:- return []- return [self.embed(content, is_query=is_query) for content in contents]-- async def embed_batch_async(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- if not contents:- return []-- # The multimodal endpoint embeds a single content per call; run the items- # concurrently while sharing the async client.- return list(- await asyncio.gather(- *(self.embed_async(content, is_query=is_query) for content in contents)- )- )-@propertydef supports_multimodal(self) -> bool:"""Multimodal inputs are supported when using the multimodal endpoint."""@@ -633,38 +567,5 @@ class VolcengineHybridEmbedder(HybridEmbedderBase):except Exception as e:raise RuntimeError(f"Volcengine hybrid embedding failed: {str(e)}") from e- def embed_batch(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- """Batch hybrid embedding-- Args:- contents: List of texts or multimodal content parts- is_query: Flag to indicate if these are query embeddings-- Returns:- List[EmbedResult]: List of embedding results-- Raises:- RuntimeError: When API call fails- """- if not contents:- return []- return [self.embed(content, is_query=is_query) for content in contents]-- async def embed_batch_async(- self, contents: List["EmbeddingInput"], is_query: bool = False- ) -> List[EmbedResult]:- if not contents:- return []-- # The multimodal endpoint embeds a single content per call; run the items- # concurrently while sharing the async client.- return list(- await asyncio.gather(- *(self.embed_async(content, is_query=is_query) for content in contents)- )- )-def get_dimension(self) -> int:return self._dimensiondiff --git a/openviking/models/embedder/voyage_embedders.py b/openviking/models/embedder/voyage_embedders.pyindex d5fbbbd38..e47310b0e 100644--- a/openviking/models/embedder/voyage_embedders.py+++ b/openviking/models/embedder/voyage_embedders.py@@ -155,66 +155,6 @@ class VoyageDenseEmbedder(DenseEmbedderBase):except Exception as e:raise RuntimeError(f"Embedding failed: {str(e)}") from e- def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:- """Batch embedding."""- if not texts:- return []-- def _call() -> List[EmbedResult]:- response = self.client.embeddings.create(**self._build_kwargs(texts))- return [EmbedResult(dense_vector=item.embedding) for item in response.data]-- try:- results = self._run_with_retry(- _call,- logger=logger,- operation_name="Voyage batch embedding",- )- # Estimate token usage for batch- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="voyage",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results- except openai.APIError as e:- raise RuntimeError(f"Voyage API error: {e.message}") from e- except Exception as e:- raise RuntimeError(f"Batch embedding failed: {str(e)}") from e-- async def embed_batch_async(- self, texts: List[str], is_query: bool = False- ) -> List[EmbedResult]:- if not texts:- return []-- client = self._get_async_client()-- async def _call() -> List[EmbedResult]:- response = await client.embeddings.create(**self._build_kwargs(texts))- return [EmbedResult(dense_vector=item.embedding) for item in response.data]-- try:- results = await self._run_with_async_retry(- _call,- logger=logger,- operation_name="Voyage async batch embedding",- )- total_tokens = sum(self._estimate_tokens(text) for text in texts)- self.update_token_usage(- model_name=self.model_name,- provider="voyage",- prompt_tokens=total_tokens,- completion_tokens=0,- )- return results- except openai.APIError as e:- raise RuntimeError(f"Voyage API error: {e.message}") from e- except Exception as e:- raise RuntimeError(f"Batch embedding failed: {str(e)}") from e-def get_dimension(self) -> int:"""Get embedding dimension."""return self._dimensiondiff --git a/tests/client/test_git_versioning_http.py b/tests/client/test_git_versioning_http.pyindex 5e7625e8d..ccc11b475 100644--- a/tests/client/test_git_versioning_http.py+++ b/tests/client/test_git_versioning_http.py@@ -56,9 +56,6 @@ def _install_fake_embedder(monkeypatch):def embed(self, text: str, is_query: bool = False) -> EmbedResult:return EmbedResult(dense_vector=[0.1] * dimension)- def embed_batch(self, texts, is_query: bool = False):- return [self.embed(t, is_query=is_query) for t in texts]-def get_dimension(self) -> int:return dimensiondiff --git a/tests/integration/test_dashscope_embedding_it.py b/tests/integration/test_dashscope_embedding_it.pyindex 8b43492ae..d63c6071b 100644--- a/tests/integration/test_dashscope_embedding_it.py+++ b/tests/integration/test_dashscope_embedding_it.py@@ -78,15 +78,6 @@ def test_text_embedding_dimension(dashscope_text_embedder):e.close()-def test_text_embedding_batch(dashscope_text_embedder):- """Batch of 3 texts returns 3 results, all correct dimension."""- texts = ["苹果是水果", "香蕉也是水果", "樱桃很好吃"]- results = dashscope_text_embedder.embed_batch(texts)- assert len(results) == 3- for r in results:- assert r.dense_vector and len(r.dense_vector) == DASHSCOPE_TEXT_DIM--# ── Multimodal embedding tests ───────────────────────────────────────────────diff --git a/tests/integration/test_gemini_e2e.py b/tests/integration/test_gemini_e2e.pyindex 1a19fee9b..da8c6a906 100644--- a/tests/integration/test_gemini_e2e.py+++ b/tests/integration/test_gemini_e2e.py@@ -51,15 +51,6 @@ class TestGeminiE2ETextEmbedding:norm = l2_norm(result.dense_vector)assert abs(norm - 1.0) < 0.01, f"Vector norm {norm} not close to 1.0"- def test_embed_batch_matches_individual(self, embedder):- texts = ["hello world", "foo bar", "test embed"]- batch_results = embedder.embed_batch(texts)- individual_results = [embedder.embed(t) for t in texts]- assert len(batch_results) == 3- for br, ir in zip(batch_results, individual_results):- sim = _cosine_similarity(br.dense_vector, ir.dense_vector)- assert sim > 0.99, f"Batch vs individual similarity {sim} too low"-def test_semantic_similarity_related_texts(self, embedder):r1 = embedder.embed("a golden retriever playing in the park")r2 = embedder.embed("a dog running outside in a field")@@ -67,28 +58,6 @@ class TestGeminiE2ETextEmbedding:sim_related = _cosine_similarity(r1.dense_vector, r2.dense_vector)sim_unrelated = _cosine_similarity(r1.dense_vector, r3.dense_vector)assert sim_related > sim_unrelated---class TestGeminiE2EAsyncBatch:- @pytest.mark.anyio- async def test_async_embed_batch_concurrent(self):- try:- import anyio # noqa: F401- except ImportError:- pytest.skip("anyio not installed")- import time-- e = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key=GOOGLE_API_KEY, dimension=128)- texts = [f"sentence {i}" for i in range(300)] # 3 batches of 100- t0 = time.monotonic()- results = await e.async_embed_batch(texts)- elapsed = time.monotonic() - t0- assert len(results) == 300- assert all(len(r.dense_vector) == 128 for r in results)- assert elapsed < 15 # concurrent should be << 3× serial RTT- e.close()--class TestGeminiE2ETaskType:def test_query_vs_document_task_types(self):doc_embedder = GeminiDenseEmbedder(diff --git a/tests/integration/test_gemini_embedding_it.py b/tests/integration/test_gemini_embedding_it.pyindex 79fa338f4..00a9503d4 100644--- a/tests/integration/test_gemini_embedding_it.py+++ b/tests/integration/test_gemini_embedding_it.py@@ -24,23 +24,6 @@ def test_embed_returns_correct_dimension(gemini_embedder):assert 0.99 < l2_norm(r.dense_vector) < 1.01-def test_embed_batch_count(gemini_embedder):- texts = ["apple", "banana", "cherry", "date", "elderberry"]- results = gemini_embedder.embed_batch(texts)- assert len(results) == len(texts)- for r in results:- assert r.dense_vector and len(r.dense_vector) == 768---def test_batch_over_100(gemini_embedder):- """150 texts auto-split into 2 batches (100 + 50)."""- texts = [f"sentence number {i}" for i in range(150)]- results = gemini_embedder.embed_batch(texts)- assert len(results) == 150- for r in results:- assert r.dense_vector and len(r.dense_vector) == 768--@pytest.mark.parametrize("model_name,_dim,token_limit", GEMINI_MODELS)def test_large_text_chunking(model_name, _dim, token_limit):"""Text exceeding the model's token limit is auto-chunked by base class."""diff --git a/tests/integration/test_quick_start_lite.py b/tests/integration/test_quick_start_lite.pyindex b0cb07e97..513dd2000 100644--- a/tests/integration/test_quick_start_lite.py+++ b/tests/integration/test_quick_start_lite.py@@ -65,10 +65,6 @@ class _FakeEmbedder:def embed(self, text: str, is_query: bool = False) -> EmbedResult:return EmbedResult(dense_vector=self._generate_pseudo_embedding(text))- def embed_batch(self, texts, is_query: bool = False):- return [self.embed(text, is_query=is_query) for text in texts]--class TestQuickStartLite(unittest.TestCase):def setUp(self):# Clean up data directory if exists to ensure fresh startdiff --git a/tests/misc/test_embedding_input_type.py b/tests/misc/test_embedding_input_type.pyindex ccb6d306d..b07e92d62 100644--- a/tests/misc/test_embedding_input_type.py+++ b/tests/misc/test_embedding_input_type.py@@ -159,7 +159,7 @@ class TestEmbeddingConfigContextualEmbedders:class TestOpenAIDenseEmbedderInputType:- """Test OpenAIDenseEmbedder input_type support in embed and embed_batch."""+ """Test OpenAIDenseEmbedder input_type support."""@patch("openai.OpenAI")def test_embed_passes_input_type_in_extra_body(self, mock_openai_class):@@ -185,30 +185,6 @@ class TestOpenAIDenseEmbedderInputType:call_kwargs = mock_client.embeddings.create.call_args[1]assert call_kwargs.get("extra_body") == {"input_type": "search_query"}- @patch("openai.OpenAI")- def test_embed_batch_passes_input_type_in_extra_body(self, mock_openai_class):- """embed_batch should pass input_type in extra_body when provided."""- from openviking.models.embedder import OpenAIDenseEmbedder-- mock_client = MagicMock()- mock_response = MagicMock()- mock_response.data = [MagicMock(embedding=[0.1] * 1536), MagicMock(embedding=[0.2] * 1536)]- mock_client.embeddings.create.return_value = mock_response- mock_openai_class.return_value = mock_client-- embedder = OpenAIDenseEmbedder(- model_name="text-embedding-3-small",- api_key="sk-test",- dimension=1536,- document_param="search_document",- )-- embedder.embed_batch(["doc 1", "doc 2"], is_query=False)-- mock_client.embeddings.create.assert_called_once()- call_kwargs = mock_client.embeddings.create.call_args[1]- assert call_kwargs.get("extra_body") == {"input_type": "search_document"}-@patch("openai.OpenAI")def test_embed_no_extra_body_when_input_type_not_set(self, mock_openai_class):"""embed should not set extra_body when input_type is None."""@@ -258,26 +234,3 @@ class TestJinaDenseEmbedderTask:mock_client.embeddings.create.assert_called_once()call_kwargs = mock_client.embeddings.create.call_args[1]assert call_kwargs.get("extra_body") == {"task": "retrieval.query"}-- @patch("openai.OpenAI")- def test_embed_batch_passes_task_in_extra_body(self, mock_openai_class):- """embed_batch should pass task in extra_body when provided."""- from openviking.models.embedder import JinaDenseEmbedder-- mock_client = MagicMock()- mock_response = MagicMock()- mock_response.data = [MagicMock(embedding=[0.1] * 1024), MagicMock(embedding=[0.2] * 1024)]- mock_client.embeddings.create.return_value = mock_response- mock_openai_class.return_value = mock_client-- embedder = JinaDenseEmbedder(- model_name="jina-embeddings-v5-text-small",- api_key="jina-test",- document_param="retrieval.passage",- )-- embedder.embed_batch(["doc 1", "doc 2"], is_query=False)-- mock_client.embeddings.create.assert_called_once()- call_kwargs = mock_client.embeddings.create.call_args[1]- assert call_kwargs.get("extra_body") == {"task": "retrieval.passage"}diff --git a/tests/server/conftest.py b/tests/server/conftest.pyindex 5a092d97c..d1672587a 100644--- a/tests/server/conftest.py+++ b/tests/server/conftest.py@@ -62,9 +62,6 @@ def _install_fake_embedder(monkeypatch):def embed(self, text: str, is_query: bool = False) -> EmbedResult:return EmbedResult(dense_vector=[0.1] * self._dimension)- def embed_batch(self, texts: list[str], is_query: bool = False) -> list[EmbedResult]:- return [self.embed(text, is_query=is_query) for text in texts]-def get_dimension(self) -> int:return self._dimensiondiff --git a/tests/session/test_session_context.py b/tests/session/test_session_context.pyindex 4deb58e3b..8b0ff0795 100644--- a/tests/session/test_session_context.py+++ b/tests/session/test_session_context.py@@ -30,9 +30,6 @@ def _install_fake_embedder(monkeypatch):def embed(self, text: str, is_query: bool = False) -> EmbedResult:return EmbedResult(dense_vector=[0.1] * 1024)- def embed_batch(self, texts: list[str], is_query: bool = False) -> list[EmbedResult]:- return [self.embed(text, is_query=is_query) for text in texts]-def get_dimension(self) -> int:return 1024diff --git a/tests/unit/test_cohere_embedder.py b/tests/unit/test_cohere_embedder.pyindex 5dfc81670..27aee11fc 100644--- a/tests/unit/test_cohere_embedder.py+++ b/tests/unit/test_cohere_embedder.py@@ -144,37 +144,6 @@ class TestCohereDenseEmbedder:payload = mock_client.post.call_args[1]["json"]assert payload["output_dimension"] == 1024- @patch("openviking.models.embedder.cohere_embedders.httpx.Client")- def test_embed_batch(self, mock_client_class):- mock_client = MagicMock()- mock_client_class.return_value = mock_client-- mock_response = MagicMock()- mock_response.json.return_value = {"embeddings": {"float": [[0.1] * 1024, [0.2] * 1024]}}- mock_response.raise_for_status = MagicMock()- mock_client.post.return_value = mock_response-- embedder = CohereDenseEmbedder(- model_name="embed-english-v3.0",- api_key="cohere-key",- )- results = embedder.embed_batch(["Hello", "World"])-- assert len(results) == 2- assert len(results[0].dense_vector) == 1024-- @patch("openviking.models.embedder.cohere_embedders.httpx.Client")- def test_embed_batch_empty(self, mock_client_class):- mock_client = MagicMock()- mock_client_class.return_value = mock_client-- embedder = CohereDenseEmbedder(- model_name="embed-english-v3.0",- api_key="cohere-key",- )- assert embedder.embed_batch([]) == []- mock_client.post.assert_not_called()-@patch("openviking.models.embedder.cohere_embedders.httpx.Client")def test_embed_api_error(self, mock_client_class):import httpxdiff --git a/tests/unit/test_dashscope_embedder.py b/tests/unit/test_dashscope_embedder.pyindex d89f6dcf9..1c4644d4e 100644--- a/tests/unit/test_dashscope_embedder.py+++ b/tests/unit/test_dashscope_embedder.py@@ -204,89 +204,6 @@ class TestDashScopeTextEmbed:embedder.embed("hello")-# ----------------------------------------------------------------------------# Text batch embed-# ------------------------------------------------------------------------------class TestDashScopeTextBatch:- """Test text mode batch embedding."""-- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- def test_batch_splits_into_chunks_of_10(self, mock_httpx, mock_openai_class):- """15 texts should produce 2 API calls (10 + 5)."""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- # First call: 10 items, second call: 5 items- mock_response_1 = MagicMock()- mock_response_1.data = [MagicMock(embedding=[0.1 * (i + 1)] * 1024) for i in range(10)]- mock_response_1.usage = MagicMock(prompt_tokens=100, total_tokens=100)-- mock_response_2 = MagicMock()- mock_response_2.data = [MagicMock(embedding=[0.2 * (i + 1)] * 1024) for i in range(5)]- mock_response_2.usage = MagicMock(prompt_tokens=50, total_tokens=50)-- mock_client.embeddings.create.side_effect = [mock_response_1, mock_response_2]-- embedder = DashScopeDenseEmbedder(- model_name="text-embedding-v4", api_key="sk-test", input_type="text"- )- results = embedder.embed_batch([f"text-{i}" for i in range(15)])-- assert len(results) == 15- assert mock_client.embeddings.create.call_count == 2- # Verify first call had 10 texts, second had 5- first_call_input = mock_client.embeddings.create.call_args_list[0][1]["input"]- assert len(first_call_input) == 10- second_call_input = mock_client.embeddings.create.call_args_list[1][1]["input"]- assert len(second_call_input) == 5-- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- def test_batch_empty_returns_empty(self, mock_httpx, mock_openai_class):- embedder = DashScopeDenseEmbedder(- model_name="text-embedding-v4", api_key="sk-test", input_type="text"- )- results = embedder.embed_batch([])- assert results == []-- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- def test_batch_single_item(self, mock_httpx, mock_openai_class):- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_embedding = MagicMock()- mock_embedding.embedding = [0.5] * 1024- mock_response = MagicMock()- mock_response.data = [mock_embedding]- mock_response.usage = MagicMock(prompt_tokens=3, total_tokens=3)- mock_client.embeddings.create.return_value = mock_response-- embedder = DashScopeDenseEmbedder(- model_name="text-embedding-v4", api_key="sk-test", input_type="text"- )- results = embedder.embed_batch(["hello"])- assert len(results) == 1- assert results[0].dense_vector == [0.5] * 1024- mock_client.embeddings.create.assert_called_once()-- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- def test_batch_error_raises_runtime_error(self, mock_httpx, mock_openai_class):- mock_client = MagicMock()- mock_openai_class.return_value = mock_client- mock_client.embeddings.create.side_effect = Exception("batch fail")-- embedder = DashScopeDenseEmbedder(- model_name="text-embedding-v4", api_key="sk-test", input_type="text"- )- with pytest.raises(RuntimeError, match="DashScope batch embedding failed"):- embedder.embed_batch(["a", "b"])--# ---------------------------------------------------------------------------# Multimodal embed# ---------------------------------------------------------------------------@@ -489,32 +406,6 @@ class TestDashScopeAsync:with pytest.raises(RuntimeError, match="DashScope embedding failed"):await embedder.embed_async("fail text")- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- @patch("openviking.models.embedder.dashscope_embedders.openai.AsyncOpenAI")- @pytest.mark.anyio- async def test_embed_batch_async_text_mode(- self, mock_async_openai_class, mock_httpx, mock_openai- ):- mock_async_client = MagicMock()- mock_async_openai_class.return_value = mock_async_client-- mock_response = MagicMock()- mock_response.data = [- MagicMock(embedding=[0.1] * 1024),- MagicMock(embedding=[0.2] * 1024),- ]- mock_response.usage = MagicMock(prompt_tokens=20, total_tokens=20)- mock_async_client.embeddings.create = AsyncMock(return_value=mock_response)-- embedder = DashScopeDenseEmbedder(- model_name="text-embedding-v4", api_key="sk-test", input_type="text"- )- results = await embedder.embed_batch_async(["a", "b"])- assert len(results) == 2- assert results[0].dense_vector == [0.1] * 1024- assert results[1].dense_vector == [0.2] * 1024-# ---------------------------------------------------------------------------# Error handling@@ -556,50 +447,6 @@ class TestDashScopeErrors:embedder.embed("hello")assert "503" in str(exc_info.value.__cause__)- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- def test_embed_batch_error(self, mock_httpx, mock_openai_class):- mock_client = MagicMock()- mock_openai_class.return_value = mock_client- mock_client.embeddings.create.side_effect = Exception("timeout")-- embedder = DashScopeDenseEmbedder(- model_name="text-embedding-v4", api_key="sk-test", input_type="text"- )- with pytest.raises(RuntimeError, match="DashScope batch embedding failed"):- embedder.embed_batch(["text1", "text2"])-- @patch("openviking.models.embedder.dashscope_embedders.openai.OpenAI")- @patch("openviking.models.embedder.dashscope_embedders.httpx.Client")- def test_multimodal_batch_sends_one_at_a_time(self, mock_httpx_class, mock_openai):- """Multimodal batch sends requests one text at a time (no chunking)."""- mock_client = MagicMock()- mock_httpx_class.return_value = mock_client-- # Each call returns a single embedding- responses = []- for i in range(3):- resp = MagicMock()- resp.json.return_value = {- "output": {"embeddings": [{"embedding": [float(i)] * 768}]},- "usage": {"total_tokens": 5, "input_tokens": 5},- }- responses.append(resp)- mock_client.post.side_effect = responses-- embedder = DashScopeDenseEmbedder(- model_name="tongyi-embedding-vision-flash",- api_key="sk-test",- input_type="multimodal",- )- results = embedder.embed_batch(["a", "b", "c"])- assert len(results) == 3- assert mock_client.post.call_count == 3- assert results[0].dense_vector == [0.0] * 768- assert results[1].dense_vector == [1.0] * 768- assert results[2].dense_vector == [2.0] * 768--# ---------------------------------------------------------------------------# Multimodal params builder# ---------------------------------------------------------------------------diff --git a/tests/unit/test_failover_embedder_permanent_advance.py b/tests/unit/test_failover_embedder_permanent_advance.pyindex 7f61bbafb..c423d1c20 100644--- a/tests/unit/test_failover_embedder_permanent_advance.py+++ b/tests/unit/test_failover_embedder_permanent_advance.py@@ -13,7 +13,6 @@ every credential of the same model."""import time-from typing import Listimport pytest@@ -43,18 +42,9 @@ class _StubEmbedder(EmbedderBase):raise self._errorreturn EmbedResult(dense_vector=[0.0] * self._dim)- def embed_batch(self, contents, is_query: bool = False) -> List[EmbedResult]:- self.calls += 1- if self._error is not None:- raise self._error- return [EmbedResult(dense_vector=[0.0] * self._dim) for _ in contents]-async def embed_async(self, content, is_query: bool = False) -> EmbedResult:return self.embed(content, is_query=is_query)- async def embed_batch_async(self, contents, is_query: bool = False) -> List[EmbedResult]:- return self.embed_batch(contents, is_query=is_query)-def _make_400_error() -> Exception:"""Construct a request-level 400 parameter error (PERMANENT, fail-fast)."""diff --git a/tests/unit/test_gemini_embedder.py b/tests/unit/test_gemini_embedder.pyindex 97413d39e..d0ed804b4 100644--- a/tests/unit/test_gemini_embedder.py+++ b/tests/unit/test_gemini_embedder.py@@ -5,7 +5,7 @@ Tests for GeminiDenseEmbedder.Pattern: patch at module import path, use MagicMock, never make real API calls."""-from unittest.mock import AsyncMock, MagicMock, patch+from unittest.mock import MagicMock, patchimport pytest@@ -155,170 +155,6 @@ class TestGeminiDenseEmbedderEmbed:mock_client.models.embed_content.assert_not_called()-class TestGeminiDenseEmbedderBatch:- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- def test_embed_batch_empty(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")- results = embedder.embed_batch([])- assert results == []- mock_client.models.embed_content.assert_not_called()-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- def test_embed_batch_skips_empty_strings(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_client.models.embed_content.return_value = _make_mock_result(- [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]]- )- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=3)- results = embedder.embed_batch(["hello", "", "world", " "])- assert len(results) == 4- # Empty positions get zero vectors- assert results[1].dense_vector == [0.0, 0.0, 0.0]- assert results[3].dense_vector == [0.0, 0.0, 0.0]- # Non-empty positions have actual embeddings- assert results[0].dense_vector is not None- assert results[2].dense_vector is not None- # API only called with non-empty texts- _, kwargs = mock_client.models.embed_content.call_args- assert kwargs["contents"] == ["hello", "world"]-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- def test_embed_batch_single_chunk(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_client.models.embed_content.return_value = _make_mock_result([[0.1], [0.2], [0.3]])- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)- results = embedder.embed_batch(["a", "b", "c"])- assert len(results) == 3- mock_client.models.embed_content.assert_called_once()- _, kwargs = mock_client.models.embed_content.call_args- assert kwargs["contents"] == ["a", "b", "c"]-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- def test_embed_batch_chunks_at_100(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_client.models.embed_content.side_effect = [- _make_mock_result([[0.1]] * 100),- _make_mock_result([[0.2]] * 10),- ]- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)- results = embedder.embed_batch([f"text{i}" for i in range(110)])- assert len(results) == 110- assert mock_client.models.embed_content.call_count == 2-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- def test_embed_batch_falls_back_to_individual_on_error(self, mock_client_class):- from google.genai.errors import APIError-- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_response = MagicMock()- mock_response.status_code = 500- mock_client.models.embed_content.side_effect = [- APIError(500, {}, response=mock_response),- _make_mock_result([[0.1]]),- _make_mock_result([[0.2]]),- ]- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)- results = embedder.embed_batch(["a", "b"])- assert len(results) == 2- assert mock_client.models.embed_content.call_count == 3---class TestGeminiDenseEmbedderAsyncBatch:- """Unit tests for async_embed_batch (uses AsyncMock, no real API)."""-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- @pytest.mark.anyio- async def test_async_embed_batch_dispatches_all_chunks(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_client.aio.models.embed_content = AsyncMock(- side_effect=[- _make_mock_result([[0.1]] * 100),- _make_mock_result([[0.2]] * 10),- ]- )- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)- results = await embedder.async_embed_batch([f"t{i}" for i in range(110)])- assert len(results) == 110- assert mock_client.aio.models.embed_content.call_count == 2-- @patch("openviking.models.embedder.gemini_embedders._TEXT_BATCH_SIZE", 1)- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- @pytest.mark.anyio- async def test_async_embed_batch_preserves_order(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- # Use orthogonal unit vectors so _l2_normalize keeps them distinguishable- mock_client.aio.models.embed_content = AsyncMock(- side_effect=[- _make_mock_result([[1.0, 0.0, 0.0]]),- _make_mock_result([[0.0, 1.0, 0.0]]),- _make_mock_result([[0.0, 0.0, 1.0]]),- ]- )- embedder = GeminiDenseEmbedder(- "gemini-embedding-2-preview",- api_key="key",- dimension=3,- max_concurrent_batches=3,- )- results = await embedder.async_embed_batch(["a", "b", "c"])- # Order must match input regardless of task completion order- assert results[0].dense_vector == pytest.approx([1.0, 0.0, 0.0])- assert results[1].dense_vector == pytest.approx([0.0, 1.0, 0.0])- assert results[2].dense_vector == pytest.approx([0.0, 0.0, 1.0])-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- @pytest.mark.anyio- async def test_async_embed_batch_error_fallback_to_individual(self, mock_client_class):- from google.genai.errors import APIError-- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_response = MagicMock()- mock_response.status_code = 500- mock_client.aio.models.embed_content = AsyncMock(- side_effect=APIError(500, {}, response=mock_response)- )- mock_client.models.embed_content.return_value = _make_mock_result([[0.1]])- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)- results = await embedder.async_embed_batch(["a", "b"])- assert len(results) == 2- assert mock_client.models.embed_content.call_count == 2-- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- @pytest.mark.anyio- async def test_async_embed_batch_empty(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")- assert await embedder.async_embed_batch([]) == []-- @patch("openviking.models.embedder.gemini_embedders._ANYIO_AVAILABLE", False)- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- @pytest.mark.anyio- async def test_async_embed_batch_raises_without_anyio(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key")- with pytest.raises(ImportError, match="anyio is required"):- await embedder.async_embed_batch(["text"])--class TestGeminiValidation:@patch("openviking.models.embedder.gemini_embedders.genai.Client")def test_all_valid_task_types_accepted(self, mock_client):@@ -449,24 +285,6 @@ class TestBuildConfig:_, kwargs = mock_client.models.embed_content.call_argsassert kwargs["config"].title == "Doc Title"- @patch("openviking.models.embedder.gemini_embedders.genai.Client")- def test_embed_batch_with_titles_falls_back(self, mock_client_class):- from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedder-- mock_client = mock_client_class.return_value- mock_client.models.embed_content.side_effect = [- _make_mock_result([[0.1]]),- _make_mock_result([[0.2]]),- ]- embedder = GeminiDenseEmbedder("gemini-embedding-2-preview", api_key="key", dimension=1)- results = embedder.embed_batch(["alpha", "beta"], titles=["Title A", "Title B"])- assert len(results) == 2- # Called once per item (not as a batch)- assert mock_client.models.embed_content.call_count == 2- # First call should have title="Title A"- first_cfg = mock_client.models.embed_content.call_args_list[0][1]["config"]- assert first_cfg.title == "Title A"-@patch("openviking.models.embedder.gemini_embedders.genai.Client")def test_repr(self, mock_client_class):from openviking.models.embedder.gemini_embedders import GeminiDenseEmbedderdiff --git a/tests/unit/test_jina_embedder.py b/tests/unit/test_jina_embedder.pyindex 06360c0d6..9ce0ba41c 100644--- a/tests/unit/test_jina_embedder.py+++ b/tests/unit/test_jina_embedder.py@@ -220,44 +220,6 @@ class TestJinaDenseEmbedder:assert "extra_body" in call_kwargsassert call_kwargs["extra_body"]["late_chunking"] is True- @patch("openviking.models.embedder.jina_embedders.openai.OpenAI")- def test_embed_batch(self, mock_openai_class):- """Test batch embedding"""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_embeddings = [MagicMock(embedding=[0.1] * 1024) for _ in range(3)]-- mock_response = MagicMock()- mock_response.data = mock_embeddings- mock_client.embeddings.create.return_value = mock_response-- embedder = JinaDenseEmbedder(- model_name="jina-embeddings-v5-text-small",- api_key="test-api-key",- )- results = embedder.embed_batch(["Hello", "World", "Test"])-- assert len(results) == 3- for result in results:- assert result.dense_vector is not None- assert len(result.dense_vector) == 1024-- @patch("openviking.models.embedder.jina_embedders.openai.OpenAI")- def test_embed_batch_empty(self, mock_openai_class):- """Test batch embedding with empty list"""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- embedder = JinaDenseEmbedder(- model_name="jina-embeddings-v5-text-small",- api_key="test-api-key",- )- results = embedder.embed_batch([])-- assert results == []- mock_client.embeddings.create.assert_not_called()-@patch("openviking.models.embedder.jina_embedders.openai.OpenAI")def test_embed_api_error(self, mock_openai_class):"""Test embedding with API error"""diff --git a/tests/unit/test_litellm_embedder.py b/tests/unit/test_litellm_embedder.pyindex 5796f7fed..49d36dca6 100644--- a/tests/unit/test_litellm_embedder.py+++ b/tests/unit/test_litellm_embedder.py@@ -61,40 +61,6 @@ class TestLiteLLMDenseEmbedder:call_kwargs = mock_litellm.embedding.call_args[1]assert call_kwargs["api_base"] == "https://openrouter.ai/api/v1"- @patch("openviking.models.embedder.litellm_embedders.litellm")- def test_embed_batch(self, mock_litellm):- """Batch embedding should return multiple results."""- vectors = [[0.1] * 1536, [0.2] * 1536]- mock_litellm.embedding.return_value = _mock_litellm_response(vectors)-- from openviking.models.embedder.litellm_embedders import LiteLLMDenseEmbedder-- embedder = LiteLLMDenseEmbedder(- model_name="openai/text-embedding-3-small",- api_key="test-key",- dimension=1536,- )- results = embedder.embed_batch(["Hello", "World"])-- assert len(results) == 2- assert results[0].dense_vector[0] == 0.1- assert results[1].dense_vector[0] == 0.2-- @patch("openviking.models.embedder.litellm_embedders.litellm")- def test_embed_batch_empty(self, mock_litellm):- """Empty batch should return empty list without API call."""- from openviking.models.embedder.litellm_embedders import LiteLLMDenseEmbedder-- embedder = LiteLLMDenseEmbedder(- model_name="openai/text-embedding-3-small",- api_key="test-key",- dimension=1536,- )- results = embedder.embed_batch([])-- assert results == []- mock_litellm.embedding.assert_not_called()-@patch("openviking.models.embedder.litellm_embedders.litellm")def test_embed_non_symmetric_query(self, mock_litellm):"""Query param should be forwarded as input_type."""diff --git a/tests/unit/test_local_embedder.py b/tests/unit/test_local_embedder.pyindex a0f0ddb40..c36c30804 100644--- a/tests/unit/test_local_embedder.py+++ b/tests/unit/test_local_embedder.py@@ -39,40 +39,12 @@ class _FakeLlama:def __init__(self, **kwargs):self.__class__.init_kwargs.append(kwargs)- self.context_params = SimpleNamespace(n_seq_max=2)def create_embedding(self, payload):self.__class__.inputs.append(payload)- if isinstance(payload, list):- return {- "data": [- {"embedding": [float(index)] * 512}- for index, _item in enumerate(payload, start=1)- ]- }return {"data": [{"embedding": [0.1] * 512}]}-class _FakeLlamaFailBatch(_FakeLlama):- def create_embedding(self, payload):- self.__class__.inputs.append(payload)- if isinstance(payload, list) and len(payload) > 1:- raise RuntimeError("llama_decode returned -1")- return {"data": [{"embedding": [0.2] * 512}]}---class _FakeLlamaSequentialOnly(_FakeLlama):- def __init__(self, **kwargs):- super().__init__(**kwargs)- self.context_params = SimpleNamespace(n_seq_max=1)-- def create_embedding(self, payload):- self.__class__.inputs.append(payload)- if isinstance(payload, list):- raise AssertionError("native batch path should not be used when n_seq_max=1")- return {"data": [{"embedding": [0.3] * 512}]}--@pytest.fixture(autouse=True)def _reset_fake_llama():_FakeLlama.init_kwargs = []@@ -150,75 +122,3 @@ def test_local_embedder_downloads_default_model_and_prefixes_query(monkeypatch,result = embedder.embed("测试问题", is_query=True)assert len(result.dense_vector) == 512assert _FakeLlama.inputs[-1] == f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}测试问题"---def test_local_embedder_embed_batch_preserves_count(monkeypatch, tmp_path):- model_path = tmp_path / "model.gguf"- model_path.write_bytes(b"gguf")-- monkeypatch.setattr(- "openviking.models.embedder.local_embedders.importlib.import_module",- lambda _name: SimpleNamespace(Llama=_FakeLlama),- )-- embedder = LocalDenseEmbedder(model_path=str(model_path))- results = embedder.embed_batch(["a", "b"], is_query=True)-- assert len(results) == 2- assert all(len(item.dense_vector) == 512 for item in results)- assert _FakeLlama.inputs[-1] == [- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}a",- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}b",- ]---def test_local_embedder_embed_batch_falls_back_to_sequential(monkeypatch, tmp_path):- model_path = tmp_path / "model.gguf"- model_path.write_bytes(b"gguf")-- _FakeLlamaFailBatch.init_kwargs = []- _FakeLlamaFailBatch.inputs = []-- monkeypatch.setattr(- "openviking.models.embedder.local_embedders.importlib.import_module",- lambda _name: SimpleNamespace(Llama=_FakeLlamaFailBatch),- )-- embedder = LocalDenseEmbedder(model_path=str(model_path))- results = embedder.embed_batch(["a", "b"], is_query=True)-- assert len(results) == 2- assert all(len(item.dense_vector) == 512 for item in results)- assert _FakeLlamaFailBatch.inputs[0] == [- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}a",- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}b",- ]- assert _FakeLlamaFailBatch.inputs[1:] == [- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}a",- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}b",- ]---def test_local_embedder_embed_batch_uses_sequential_mode_when_native_batch_unsupported(- monkeypatch, tmp_path-):- model_path = tmp_path / "model.gguf"- model_path.write_bytes(b"gguf")-- _FakeLlamaSequentialOnly.init_kwargs = []- _FakeLlamaSequentialOnly.inputs = []-- monkeypatch.setattr(- "openviking.models.embedder.local_embedders.importlib.import_module",- lambda _name: SimpleNamespace(Llama=_FakeLlamaSequentialOnly),- )-- embedder = LocalDenseEmbedder(model_path=str(model_path))- results = embedder.embed_batch(["a", "b"], is_query=True)-- assert len(results) == 2- assert all(len(item.dense_vector) == 512 for item in results)- assert _FakeLlamaSequentialOnly.inputs == [- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}a",- f"{DEFAULT_BGE_ZH_QUERY_INSTRUCTION}b",- ]diff --git a/tests/unit/test_openai_embedder.py b/tests/unit/test_openai_embedder.pyindex e9e20ad80..89fb9db98 100644--- a/tests/unit/test_openai_embedder.py+++ b/tests/unit/test_openai_embedder.py@@ -34,32 +34,6 @@ class TestOpenAIDenseEmbedder:call_kwargs = mock_client.embeddings.create.call_args[1]assert "dimensions" not in call_kwargs- @patch("openviking.models.embedder.openai_embedders.openai.OpenAI")- def test_embed_batch_does_not_send_dimensions(self, mock_openai_class):- """OpenAI embed_batch should omit dimensions param"""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_embedding1 = MagicMock()- mock_embedding1.embedding = [0.1] * 1536- mock_embedding2 = MagicMock()- mock_embedding2.embedding = [0.2] * 1536-- mock_response = MagicMock()- mock_response.data = [mock_embedding1, mock_embedding2]- mock_client.embeddings.create.return_value = mock_response-- embedder = OpenAIDenseEmbedder(- model_name="text-embedding-3-small",- api_key="test-api-key",- dimension=512,- )-- embedder.embed_batch(["Hello", "World"])-- call_kwargs = mock_client.embeddings.create.call_args[1]- assert "dimensions" not in call_kwargs-@patch("openviking.models.embedder.openai_embedders.openai.OpenAI")def test_embed_with_input_type_none(self, mock_openai_class):"""OpenAI embed should not include extra_body when input_type is None"""@@ -133,85 +107,6 @@ class TestOpenAIDenseEmbedder:assert "extra_body" in call_kwargsassert call_kwargs["extra_body"] == {"input_type": "passage"}- @patch("openviking.models.embedder.openai_embedders.openai.OpenAI")- def test_embed_batch_with_input_type_none(self, mock_openai_class):- """OpenAI embed_batch should not include extra_body when input_type is None"""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_embedding1 = MagicMock()- mock_embedding1.embedding = [0.1] * 1536- mock_embedding2 = MagicMock()- mock_embedding2.embedding = [0.2] * 1536-- mock_response = MagicMock()- mock_response.data = [mock_embedding1, mock_embedding2]- mock_client.embeddings.create.return_value = mock_response-- embedder = OpenAIDenseEmbedder(- model_name="text-embedding-3-small",- api_key="test-api-key",- )-- embedder.embed_batch(["Hello", "World"])-- call_kwargs = mock_client.embeddings.create.call_args[1]- assert "extra_body" not in call_kwargs-- @patch("openviking.models.embedder.openai_embedders.openai.OpenAI")- def test_embed_batch_with_context_query(self, mock_openai_class):- """OpenAI embed_batch should include extra_body with input_type='query' when is_query=True"""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_embedding1 = MagicMock()- mock_embedding1.embedding = [0.1] * 1536- mock_embedding2 = MagicMock()- mock_embedding2.embedding = [0.2] * 1536-- mock_response = MagicMock()- mock_response.data = [mock_embedding1, mock_embedding2]- mock_client.embeddings.create.return_value = mock_response-- embedder = OpenAIDenseEmbedder(- model_name="text-embedding-3-small",- api_key="test-api-key",- query_param="query",- )-- embedder.embed_batch(["Hello", "World"], is_query=True)-- call_kwargs = mock_client.embeddings.create.call_args[1]- assert "extra_body" in call_kwargs- assert call_kwargs["extra_body"] == {"input_type": "query"}-- @patch("openviking.models.embedder.openai_embedders.openai.OpenAI")- def test_embed_batch_with_context_document(self, mock_openai_class):- """OpenAI embed_batch should include extra_body with input_type='passage' when is_query=False"""- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_embedding1 = MagicMock()- mock_embedding1.embedding = [0.1] * 1536- mock_embedding2 = MagicMock()- mock_embedding2.embedding = [0.2] * 1536-- mock_response = MagicMock()- mock_response.data = [mock_embedding1, mock_embedding2]- mock_client.embeddings.create.return_value = mock_response-- embedder = OpenAIDenseEmbedder(- model_name="text-embedding-3-small",- api_key="test-api-key",- document_param="passage",- )-- embedder.embed_batch(["Hello", "World"], is_query=False)-- call_kwargs = mock_client.embeddings.create.call_args[1]- assert "extra_body" in call_kwargs- assert call_kwargs["extra_body"] == {"input_type": "passage"}-@patch("openviking.models.embedder.openai_embedders.openai.OpenAI")def test_telemetry_skipped_when_no_usage(self, mock_openai_class):"""_update_telemetry_token_usage should no-op when response has no usage"""diff --git a/tests/unit/test_voyage_embedder.py b/tests/unit/test_voyage_embedder.pyindex a508639a5..fffcbad89 100644--- a/tests/unit/test_voyage_embedder.py+++ b/tests/unit/test_voyage_embedder.py@@ -97,40 +97,6 @@ class TestVoyageDenseEmbedder:assert call_kwargs["extra_body"]["output_dimension"] == 512assert "dimensions" not in call_kwargs- @patch("openviking.models.embedder.voyage_embedders.openai.OpenAI")- def test_embed_batch(self, mock_openai_class):- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- mock_response = MagicMock()- mock_response.data = [- MagicMock(embedding=[0.1] * 1024),- MagicMock(embedding=[0.2] * 1024),- ]- mock_client.embeddings.create.return_value = mock_response-- embedder = VoyageDenseEmbedder(- model_name="voyage-4-lite",- api_key="voyage-key",- )- results = embedder.embed_batch(["Hello", "World"])-- assert len(results) == 2- assert len(results[0].dense_vector) == 1024- assert len(results[1].dense_vector) == 1024-- @patch("openviking.models.embedder.voyage_embedders.openai.OpenAI")- def test_embed_batch_empty(self, mock_openai_class):- mock_client = MagicMock()- mock_openai_class.return_value = mock_client-- embedder = VoyageDenseEmbedder(- model_name="voyage-4-lite",- api_key="voyage-key",- )- assert embedder.embed_batch([]) == []- mock_client.embeddings.create.assert_not_called()-@patch("openviking.models.embedder.voyage_embedders.openai.OpenAI")def test_embed_api_error(self, mock_openai_class):import openai