Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

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.md
index 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.py
index 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 content
return 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]
-
@property
def 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.py
index 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.py
index 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.py
index 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, Optional
from google import genai
from google.genai import types
@@ -25,8 +24,6 @@ from openviking_cli.utils import get_logger
logger = 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_param
self._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_batches
def _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._dimension
diff --git a/openviking/models/embedder/jina_embedders.py b/openviking/models/embedder/jina_embedders.py
index 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 dimension
diff --git a/openviking/models/embedder/litellm_embedders.py b/openviking/models/embedder/litellm_embedders.py
index 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.py
index 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
-
@staticmethod
def _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._dimension
diff --git a/openviking/models/embedder/minimax_embedders.py b/openviking/models/embedder/minimax_embedders.py
index 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._dimension
diff --git a/openviking/models/embedder/openai_embedders.py b/openviking/models/embedder/openai_embedders.py
index 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 dimension
diff --git a/openviking/models/embedder/vikingdb_embedders.py b/openviking/models/embedder/vikingdb_embedders.py
index 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 2048
diff --git a/openviking/models/embedder/volcengine_embedders.py b/openviking/models/embedder/volcengine_embedders.py
index 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 asyncio
from typing import Any, Dict, List, Optional
import 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)
- )
- )
-
@property
def 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._dimension
diff --git a/openviking/models/embedder/voyage_embedders.py b/openviking/models/embedder/voyage_embedders.py
index 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._dimension
diff --git a/tests/client/test_git_versioning_http.py b/tests/client/test_git_versioning_http.py
index 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 dimension
diff --git a/tests/integration/test_dashscope_embedding_it.py b/tests/integration/test_dashscope_embedding_it.py
index 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.py
index 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.py
index 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.py
index 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 start
diff --git a/tests/misc/test_embedding_input_type.py b/tests/misc/test_embedding_input_type.py
index 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.py
index 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._dimension
diff --git a/tests/session/test_session_context.py b/tests/session/test_session_context.py
index 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 1024
diff --git a/tests/unit/test_cohere_embedder.py b/tests/unit/test_cohere_embedder.py
index 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 httpx
diff --git a/tests/unit/test_dashscope_embedder.py b/tests/unit/test_dashscope_embedder.py
index 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.py
index 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 List
import pytest
@@ -43,18 +42,9 @@ class _StubEmbedder(EmbedderBase):
raise self._error
return 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.py
index 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, patch
import 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_args
assert 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 GeminiDenseEmbedder
diff --git a/tests/unit/test_jina_embedder.py b/tests/unit/test_jina_embedder.py
index 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_kwargs
assert 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.py
index 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.py
index 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) == 512
assert _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.py
index 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_kwargs
assert 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.py
index 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"] == 512
assert "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