Skip to content

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

fix: ov status shows embedding and rerank models usage (#1191)

MaojiaShengd739f742d7bf
diff --git a/crates/ov_cli/src/commands/observer.rs b/crates/ov_cli/src/commands/observer.rs
index 83caa5ef7..d07c2ebe1 100644
--- a/crates/ov_cli/src/commands/observer.rs
+++ b/crates/ov_cli/src/commands/observer.rs
@@ -18,12 +18,6 @@ pub async fn vikingdb(
Ok(())
}
-pub async fn vlm(client: &HttpClient, output_format: OutputFormat, compact: bool) -> Result<()> {
- let response: serde_json::Value = client.get("/api/v1/observer/vlm", &[]).await?;
- output_success(&response, output_format, compact);
- Ok(())
-}
-
pub async fn transaction(
client: &HttpClient,
output_format: OutputFormat,
@@ -49,3 +43,9 @@ pub async fn system(client: &HttpClient, output_format: OutputFormat, compact: b
output_success(&response, output_format, compact);
Ok(())
}
+
+pub async fn models(client: &HttpClient, output_format: OutputFormat, compact: bool) -> Result<()> {
+ let response: serde_json::Value = client.get("/api/v1/observer/models", &[]).await?;
+ output_success(&response, output_format, compact);
+ Ok(())
+}
diff --git a/crates/ov_cli/src/main.rs b/crates/ov_cli/src/main.rs
index 0c656412c..1ef5bf899 100644
--- a/crates/ov_cli/src/main.rs
+++ b/crates/ov_cli/src/main.rs
@@ -506,8 +506,8 @@ enum ObserverCommands {
Queue,
/// Get VikingDB status
Vikingdb,
- /// Get VLM status
- Vlm,
+ /// Get models status (VLM, Embedding, Rerank)
+ Models,
/// Get transaction system status
Transaction,
/// Get retrieval quality metrics
@@ -1013,8 +1013,8 @@ async fn handle_observer(cmd: ObserverCommands, ctx: CliContext) -> Result<()> {
ObserverCommands::Vikingdb => {
commands::observer::vikingdb(&client, ctx.output_format, ctx.compact).await
}
- ObserverCommands::Vlm => {
- commands::observer::vlm(&client, ctx.output_format, ctx.compact).await
+ ObserverCommands::Models => {
+ commands::observer::models(&client, ctx.output_format, ctx.compact).await
}
ObserverCommands::Transaction => {
commands::observer::transaction(&client, ctx.output_format, ctx.compact).await
diff --git a/openviking/models/embedder/base.py b/openviking/models/embedder/base.py
index 4aa101c81..46e3b5b9b 100644
--- a/openviking/models/embedder/base.py
+++ b/openviking/models/embedder/base.py
@@ -11,6 +11,19 @@ from openviking.utils.model_retry import retry_sync
T = TypeVar("T")
+_token_tracker_instance = None
+
+
+def _get_token_tracker():
+ """Lazy import to avoid circular dependency."""
+ global _token_tracker_instance
+ if _token_tracker_instance is None:
+ from openviking.models.vlm.token_usage import TokenUsageTracker
+
+ _token_tracker_instance = TokenUsageTracker()
+ return _token_tracker_instance
+
+
def truncate_and_normalize(embedding: List[float], dimension: Optional[int]) -> List[float]:
"""Truncate and L2 normalize embedding vector
@@ -77,6 +90,10 @@ class EmbedderBase(ABC):
self.model_name = model_name
self.config = config or {}
self.max_retries = int(self.config.get("max_retries", 3))
+ self.provider = self.config.get("provider", "unknown")
+
+ # Token usage tracking
+ self._token_tracker = _get_token_tracker()
@abstractmethod
def embed(self, text: str, is_query: bool = False) -> EmbedResult:
@@ -130,6 +147,57 @@ class EmbedderBase(ABC):
"""Check if result is hybrid (contains both dense and sparse vectors)"""
return False
+ def update_token_usage(
+ self,
+ model_name: str,
+ provider: str,
+ prompt_tokens: int,
+ completion_tokens: int,
+ ) -> None:
+ """Update token usage
+
+ Args:
+ model_name: Model name
+ provider: Provider name (openai, volcengine, etc.)
+ prompt_tokens: Number of input tokens
+ completion_tokens: Number of output tokens
+ """
+ self._token_tracker.update(
+ model_name=model_name,
+ provider=provider,
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
+ )
+
+ def get_token_usage(self) -> Dict[str, Any]:
+ """Get token usage
+
+ Returns:
+ Dict[str, Any]: Token usage dictionary
+ """
+ return self._token_tracker.to_dict()
+
+ def reset_token_usage(self) -> None:
+ """Reset token usage"""
+ self._token_tracker.reset()
+
+ def _estimate_tokens(self, text: str) -> int:
+ """Estimate token count from text (1 token ≈ 4 characters for English)
+
+ Args:
+ text: Input text to estimate tokens for
+
+ Returns:
+ Estimated token count
+ """
+ if not text:
+ return 0
+ # Approximate: 1 token ≈ 4 characters
+ # For Chinese characters, 1 token ≈ 1-2 characters
+ chinese_chars = sum(1 for c in text if "\u4e00" <= c <= "\u9fff")
+ other_chars = len(text) - chinese_chars
+ return max(1, (chinese_chars // 1) + (other_chars // 4))
+
class DenseEmbedderBase(EmbedderBase):
"""Dense embedder base class that returns dense vectors
diff --git a/openviking/models/embedder/cohere_embedders.py b/openviking/models/embedder/cohere_embedders.py
index d49269ffe..d80226d3b 100644
--- a/openviking/models/embedder/cohere_embedders.py
+++ b/openviking/models/embedder/cohere_embedders.py
@@ -70,9 +70,7 @@ class CohereDenseEmbedder(DenseEmbedderBase):
# Prefer server-side output_dimension when the model supports it
self._use_server_dim = (
- allowed is not None
- and dimension is not None
- and dimension != self._native_dimension
+ allowed is not None and dimension is not None and dimension != self._native_dimension
)
# Fallback to client-side truncation for v3 models
self._needs_truncation = (
@@ -113,9 +111,20 @@ class CohereDenseEmbedder(DenseEmbedderBase):
input_type = "search_query" if is_query else "search_document"
try:
vectors = self._call_api([text], input_type)
- return EmbedResult(dense_vector=self._normalize_vector(vectors[0]))
+ result = EmbedResult(dense_vector=self._normalize_vector(vectors[0]))
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="cohere",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
except httpx.HTTPStatusError as e:
- raise RuntimeError(f"Cohere API error: {e.response.status_code} {e.response.text}") from e
+ raise RuntimeError(
+ f"Cohere API error: {e.response.status_code} {e.response.text}"
+ ) from e
except Exception as e:
raise RuntimeError(f"Cohere embedding failed: {e}") from e
@@ -128,12 +137,20 @@ class CohereDenseEmbedder(DenseEmbedderBase):
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
- )
+ 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
+ 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
diff --git a/openviking/models/embedder/gemini_embedders.py b/openviking/models/embedder/gemini_embedders.py
index c233fc98e..0d8ae74af 100644
--- a/openviking/models/embedder/gemini_embedders.py
+++ b/openviking/models/embedder/gemini_embedders.py
@@ -219,13 +219,24 @@ class GeminiDenseEmbedder(DenseEmbedderBase):
return EmbedResult(dense_vector=vector)
try:
- if _HTTP_RETRY_AVAILABLE:
- return _call()
- return self._run_with_retry(
- _call,
- logger=logger,
- operation_name="Gemini embedding",
+ result = (
+ _call()
+ if _HTTP_RETRY_AVAILABLE
+ else self._run_with_retry(
+ _call,
+ logger=logger,
+ operation_name="Gemini embedding",
+ )
+ )
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="gemini",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
)
+ return result
except (APIError, ClientError) as e:
_raise_api_error(e, self.model_name)
@@ -300,6 +311,8 @@ class GeminiDenseEmbedder(DenseEmbedderBase):
)
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 async_embed_batch(self, texts: List[str]) -> List[EmbedResult]:
@@ -331,12 +344,21 @@ class GeminiDenseEmbedder(DenseEmbedderBase):
)
for emb in response.embeddings
]
+ # Track token usage for successful API call
+ total_tokens = sum(self._estimate_tokens(text) for text in batch)
+ 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",
e.code,
len(batch),
)
+ # Token usage will be tracked via self.embed() calls
results[idx] = [
await anyio.to_thread.run_sync(self.embed, text) for text in batch
]
diff --git a/openviking/models/embedder/jina_embedders.py b/openviking/models/embedder/jina_embedders.py
index d17691d9c..e13765421 100644
--- a/openviking/models/embedder/jina_embedders.py
+++ b/openviking/models/embedder/jina_embedders.py
@@ -184,11 +184,20 @@ class JinaDenseEmbedder(DenseEmbedderBase):
return EmbedResult(dense_vector=vector)
try:
- return self._run_with_retry(
+ result = self._run_with_retry(
_call,
logger=logger,
operation_name="Jina embedding",
)
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="jina",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
except openai.APIError as e:
self._raise_task_error(e)
raise RuntimeError(f"Jina API error: {e.message}") from e
@@ -225,11 +234,20 @@ class JinaDenseEmbedder(DenseEmbedderBase):
return [EmbedResult(dense_vector=item.embedding) for item in response.data]
try:
- return self._run_with_retry(
+ 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
diff --git a/openviking/models/embedder/litellm_embedders.py b/openviking/models/embedder/litellm_embedders.py
index 9fd76f7fe..441b85fa0 100644
--- a/openviking/models/embedder/litellm_embedders.py
+++ b/openviking/models/embedder/litellm_embedders.py
@@ -122,7 +122,7 @@ class LiteLLMDenseEmbedder(DenseEmbedderBase):
return kwargs
def _update_telemetry_token_usage(self, response) -> None:
- """Update telemetry with token usage from response."""
+ """Update telemetry and token usage from response."""
usage = getattr(response, "usage", None)
if not usage:
return
@@ -135,12 +135,22 @@ class LiteLLMDenseEmbedder(DenseEmbedderBase):
prompt_tokens = _usage_value("prompt_tokens", 0)
total_tokens = _usage_value("total_tokens", prompt_tokens)
output_tokens = max(total_tokens - prompt_tokens, 0)
+
+ # Update telemetry
get_current_telemetry().add_token_usage_by_source(
"embedding",
prompt_tokens,
output_tokens,
)
+ # Update token usage tracker
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="litellm",
+ prompt_tokens=prompt_tokens,
+ completion_tokens=output_tokens,
+ )
+
def embed(self, text: str, is_query: bool = False) -> EmbedResult:
"""Perform dense embedding on text via litellm.
diff --git a/openviking/models/embedder/minimax_embedders.py b/openviking/models/embedder/minimax_embedders.py
index db143fe47..7a5d79f3c 100644
--- a/openviking/models/embedder/minimax_embedders.py
+++ b/openviking/models/embedder/minimax_embedders.py
@@ -164,7 +164,16 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):
def embed(self, text: str, is_query: bool = False) -> EmbedResult:
"""Perform dense embedding on text"""
vectors = self._call_api([text], is_query=is_query)
- return EmbedResult(dense_vector=vectors[0])
+ result = EmbedResult(dense_vector=vectors[0])
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="minimax",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:
"""Batch embedding"""
@@ -174,7 +183,16 @@ class MinimaxDenseEmbedder(DenseEmbedderBase):
# 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)
- return [EmbedResult(dense_vector=v) for v in vectors]
+ 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
def get_dimension(self) -> int:
"""Get embedding dimension"""
diff --git a/openviking/models/embedder/openai_embedders.py b/openviking/models/embedder/openai_embedders.py
index 7bb32ad57..0e67069de 100644
--- a/openviking/models/embedder/openai_embedders.py
+++ b/openviking/models/embedder/openai_embedders.py
@@ -163,11 +163,21 @@ class OpenAIDenseEmbedder(DenseEmbedderBase):
prompt_tokens = _usage_value("prompt_tokens", 0)
total_tokens = _usage_value("total_tokens", prompt_tokens)
- output_tokens = max(total_tokens - prompt_tokens, 0)
+ completion_tokens = max(total_tokens - prompt_tokens, 0)
+
+ # Update telemetry
get_current_telemetry().add_token_usage_by_source(
"embedding",
prompt_tokens,
- output_tokens,
+ completion_tokens,
+ )
+
+ # Update token tracker
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider=self._provider,
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
)
def _parse_param_string(self, param: Optional[str]) -> Dict[str, str]:
diff --git a/openviking/models/embedder/vikingdb_embedders.py b/openviking/models/embedder/vikingdb_embedders.py
index 8d31669d5..a6042316d 100644
--- a/openviking/models/embedder/vikingdb_embedders.py
+++ b/openviking/models/embedder/vikingdb_embedders.py
@@ -136,11 +136,20 @@ class VikingDBDenseEmbedder(DenseEmbedderBase, VikingDBClientMixin):
return EmbedResult(dense_vector=dense_vector)
- return self._run_with_retry(
+ result = self._run_with_retry(
_call,
logger=logger,
operation_name="VikingDB embedding",
)
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="volcengine",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:
if not texts:
@@ -157,11 +166,20 @@ class VikingDBDenseEmbedder(DenseEmbedderBase, VikingDBClientMixin):
for item in raw_results
]
- return self._run_with_retry(
+ 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
def get_dimension(self) -> int:
return self.dimension if self.dimension else 2048
@@ -201,11 +219,20 @@ class VikingDBSparseEmbedder(SparseEmbedderBase, VikingDBClientMixin):
return EmbedResult(sparse_vector=sparse_vector)
- return self._run_with_retry(
+ result = self._run_with_retry(
_call,
logger=logger,
operation_name="VikingDB sparse embedding",
)
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="volcengine",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:
if not texts:
@@ -220,11 +247,20 @@ class VikingDBSparseEmbedder(SparseEmbedderBase, VikingDBClientMixin):
for item in raw_results
]
- return self._run_with_retry(
+ 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
class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):
@@ -272,11 +308,20 @@ class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):
return EmbedResult(dense_vector=dense_vector, sparse_vector=sparse_vector)
- return self._run_with_retry(
+ result = self._run_with_retry(
_call,
logger=logger,
operation_name="VikingDB hybrid embedding",
)
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="volcengine",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
def embed_batch(self, texts: List[str], is_query: bool = False) -> List[EmbedResult]:
if not texts:
@@ -297,11 +342,20 @@ class VikingDBHybridEmbedder(HybridEmbedderBase, VikingDBClientMixin):
results.append(EmbedResult(dense_vector=dense_vector, sparse_vector=sparse_vector))
return results
- return self._run_with_retry(
+ 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
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 2fbba2d61..03f9915f5 100644
--- a/openviking/models/embedder/volcengine_embedders.py
+++ b/openviking/models/embedder/volcengine_embedders.py
@@ -121,11 +121,21 @@ class VolcengineDenseEmbedder(DenseEmbedderBase):
prompt_tokens = _usage_value("prompt_tokens", 0)
total_tokens = _usage_value("total_tokens", prompt_tokens)
- output_tokens = max(total_tokens - prompt_tokens, 0)
+ completion_tokens = max(total_tokens - prompt_tokens, 0)
+
+ # Update telemetry
get_current_telemetry().add_token_usage_by_source(
"embedding",
prompt_tokens,
- output_tokens,
+ completion_tokens,
+ )
+
+ # Update token tracker
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="volcengine",
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
)
def embed(self, text: str, is_query: bool = False) -> EmbedResult:
@@ -255,6 +265,35 @@ class VolcengineSparseEmbedder(SparseEmbedderBase):
ark_kwargs["base_url"] = self.api_base
self.client = volcenginesdkarkruntime.Ark(**ark_kwargs)
+ def _update_telemetry_token_usage(self, response) -> None:
+ usage = getattr(response, "usage", None)
+ if not usage:
+ return
+
+ def _usage_value(key: str, default: int = 0) -> int:
+ if isinstance(usage, dict):
+ return int(usage.get(key, default) or default)
+ return int(getattr(usage, key, default) or default)
+
+ prompt_tokens = _usage_value("prompt_tokens", 0)
+ total_tokens = _usage_value("total_tokens", prompt_tokens)
+ completion_tokens = max(total_tokens - prompt_tokens, 0)
+
+ # Update telemetry
+ get_current_telemetry().add_token_usage_by_source(
+ "embedding",
+ prompt_tokens,
+ completion_tokens,
+ )
+
+ # Update token tracker
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="volcengine",
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
+ )
+
def embed(self, text: str, is_query: bool = False) -> EmbedResult:
"""Perform sparse embedding on text
@@ -276,6 +315,7 @@ class VolcengineSparseEmbedder(SparseEmbedderBase):
model=self.model_name,
sparse_embedding={"type": "enabled"},
)
+ self._update_telemetry_token_usage(response)
item = response.data
sparse_vector = getattr(item, "sparse_embedding", None)
return EmbedResult(sparse_vector=process_sparse_embedding(sparse_vector))
@@ -351,6 +391,35 @@ class VolcengineHybridEmbedder(HybridEmbedderBase):
self.client = volcenginesdkarkruntime.Ark(**ark_kwargs)
self._dimension = dimension or 2048
+ def _update_telemetry_token_usage(self, response) -> None:
+ usage = getattr(response, "usage", None)
+ if not usage:
+ return
+
+ def _usage_value(key: str, default: int = 0) -> int:
+ if isinstance(usage, dict):
+ return int(usage.get(key, default) or default)
+ return int(getattr(usage, key, default) or default)
+
+ prompt_tokens = _usage_value("prompt_tokens", 0)
+ total_tokens = _usage_value("total_tokens", prompt_tokens)
+ completion_tokens = max(total_tokens - prompt_tokens, 0)
+
+ # Update telemetry
+ get_current_telemetry().add_token_usage_by_source(
+ "embedding",
+ prompt_tokens,
+ completion_tokens,
+ )
+
+ # Update token tracker
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="volcengine",
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
+ )
+
def embed(self, text: str, is_query: bool = False) -> EmbedResult:
"""Perform hybrid embedding on text
@@ -373,6 +442,7 @@ class VolcengineHybridEmbedder(HybridEmbedderBase):
model=self.model_name,
sparse_embedding={"type": "enabled"},
)
+ self._update_telemetry_token_usage(response)
item = response.data
dense_vector = truncate_and_normalize(item.embedding, self.dimension)
sparse_vector = getattr(item, "sparse_embedding", None)
diff --git a/openviking/models/embedder/voyage_embedders.py b/openviking/models/embedder/voyage_embedders.py
index ff0c65a08..c4c366942 100644
--- a/openviking/models/embedder/voyage_embedders.py
+++ b/openviking/models/embedder/voyage_embedders.py
@@ -97,11 +97,20 @@ class VoyageDenseEmbedder(DenseEmbedderBase):
return EmbedResult(dense_vector=vector)
try:
- return self._run_with_retry(
+ result = self._run_with_retry(
_call,
logger=logger,
operation_name="Voyage embedding",
)
+ # Estimate token usage
+ estimated_tokens = self._estimate_tokens(text)
+ self.update_token_usage(
+ model_name=self.model_name,
+ provider="voyage",
+ prompt_tokens=estimated_tokens,
+ completion_tokens=0,
+ )
+ return result
except openai.APIError as e:
raise RuntimeError(f"Voyage API error: {e.message}") from e
except Exception as e:
@@ -121,11 +130,20 @@ class VoyageDenseEmbedder(DenseEmbedderBase):
return [EmbedResult(dense_vector=item.embedding) for item in response.data]
try:
- return self._run_with_retry(
+ 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:
diff --git a/openviking/models/rerank/__init__.py b/openviking/models/rerank/__init__.py
new file mode 100644
index 000000000..2cf5ae3a3
--- /dev/null
+++ b/openviking/models/rerank/__init__.py
@@ -0,0 +1,25 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+"""
+Rerank models for OpenViking.
+
+Provides rerank functionality for hierarchical retrieval with multiple provider support:
+- vikingdb: VikingDB's native rerank service
+- cohere: Cohere Rerank v3.5 API
+- litellm: LiteLLM rerank (supports multiple providers)
+- openai: OpenAI-compatible rerank API
+"""
+
+from openviking.models.rerank.base import RerankBase
+from openviking.models.rerank.cohere_rerank import CohereRerankClient
+from openviking.models.rerank.litellm_rerank import LiteLLMRerankClient
+from openviking.models.rerank.openai_rerank import OpenAIRerankClient
+from openviking.models.rerank.volcengine_rerank import RerankClient
+
+__all__ = [
+ "RerankBase",
+ "RerankClient",
+ "CohereRerankClient",
+ "LiteLLMRerankClient",
+ "OpenAIRerankClient",
+]
diff --git a/openviking/models/rerank/base.py b/openviking/models/rerank/base.py
new file mode 100644
index 000000000..94e89434b
--- /dev/null
+++ b/openviking/models/rerank/base.py
@@ -0,0 +1,113 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+"""
+RerankBase: Base class for all rerank clients.
+
+Provides common token usage tracking functionality.
+"""
+
+from typing import Any, Dict
+
+_token_tracker_instance = None
+
+
+def _get_token_tracker():
+ """Lazy import to avoid circular dependency. Returns shared singleton instance."""
+ global _token_tracker_instance
+ if _token_tracker_instance is None:
+ from openviking.models.vlm.token_usage import TokenUsageTracker
+
+ _token_tracker_instance = TokenUsageTracker()
+ return _token_tracker_instance
+
+
+class RerankBase:
+ """Base class for all rerank clients
+
+ Provides common token usage tracking functionality.
+ """
+
+ def __init__(self):
+ """Initialize rerank client with token tracking"""
+ # Token usage tracking
+ self._token_tracker = _get_token_tracker()
+
+ def _estimate_tokens(self, text: str) -> int:
+ """Estimate token count for text (rough approximation: 1 token ≈ 4 characters)."""
+ return max(1, len(text) // 4)
+
+ def update_token_usage(
+ self,
+ model_name: str,
+ provider: str,
+ prompt_tokens: int,
+ completion_tokens: int,
+ ) -> None:
+ """Update token usage
+
+ Args:
+ model_name: Model name
+ provider: Provider name (vikingdb, openai, cohere, litellm, etc.)
+ prompt_tokens: Number of input tokens
+ completion_tokens: Number of output tokens
+ """
+ self._token_tracker.update(
+ model_name=model_name,
+ provider=provider,
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
+ )
+
+ def _extract_and_update_token_usage(
+ self,
+ response_data: dict,
+ query: str,
+ documents: list,
+ ) -> None:
+ """Extract and update token usage from API response.
+
+ Args:
+ response_data: Raw API response dict
+ query: Query text (for estimation if needed)
+ documents: List of documents (for estimation if needed)
+ """
+ prompt_tokens = 0
+ completion_tokens = 0
+
+ # Try to extract token usage from response meta (Coherever format)
+ meta = response_data.get("meta", {})
+ if isinstance(meta, dict):
+ billed_units = meta.get("billed_units", {})
+ if isinstance(billed_units, dict):
+ prompt_tokens = billed_units.get("input_tokens", 0)
+ completion_tokens = billed_units.get("output_tokens", 0)
+
+ # If no token info in response, estimate based on text
+ if prompt_tokens == 0 and completion_tokens == 0:
+ prompt_tokens = self._estimate_tokens(query)
+ for doc in documents:
+ prompt_tokens += self._estimate_tokens(str(doc))
+ # Rerank typically doesn't generate output tokens, just scores
+ completion_tokens = 0
+
+ # Get model name
+ model_name = getattr(self, "model_name", None) or getattr(self, "model", None) or "unknown"
+
+ self.update_token_usage(
+ model_name=model_name,
+ provider=self.provider,
+ prompt_tokens=prompt_tokens,
+ completion_tokens=completion_tokens,
+ )
+
+ def get_token_usage(self) -> Dict[str, Any]:
+ """Get token usage
+
+ Returns:
+ Dict[str, Any]: Token usage dictionary
+ """
+ return self._token_tracker.to_dict()
+
+ def reset_token_usage(self) -> None:
+ """Reset token usage"""
+ self._token_tracker.reset()
diff --git a/openviking_cli/utils/cohere_rerank.py b/openviking/models/rerank/cohere_rerank.py
similarity index 86%
rename from openviking_cli/utils/cohere_rerank.py
rename to openviking/models/rerank/cohere_rerank.py
index e930d8145..473bb982a 100644
--- a/openviking_cli/utils/cohere_rerank.py
+++ b/openviking/models/rerank/cohere_rerank.py
@@ -7,16 +7,18 @@ Drop-in replacement for VikingDB RerankClient, using Cohere's Rerank v3.5 API.
Same interface: rerank_batch(query, documents) -> List[float]
"""
+# For logging, use Python's built-in logging
+import logging
from typing import List, Optional
import httpx
-from openviking_cli.utils.logger import get_logger
+from openviking.models.rerank.base import RerankBase
-logger = get_logger(__name__)
+logger = logging.getLogger(__name__)
-class CohereRerankClient:
+class CohereRerankClient(RerankBase):
"""Cohere Rerank API client — same interface as VikingDB RerankClient."""
def __init__(
@@ -25,9 +27,11 @@ class CohereRerankClient:
model: str = "rerank-v3.5",
api_base: str = "https://api.cohere.com",
):
+ super().__init__()
self.api_key = api_key
self.model = model
self.api_base = api_base.rstrip("/")
+ self.provider = "cohere"
self._client = httpx.Client(
base_url=self.api_base,
headers={
@@ -66,6 +70,9 @@ class CohereRerankClient:
resp.raise_for_status()
data = resp.json()
+ # Update token usage tracking
+ self._extract_and_update_token_usage(data, query, documents)
+
# Cohere returns results sorted by score desc with index field
# We need to map back to original order
scores = [0.0] * len(documents)
@@ -101,7 +108,5 @@ class CohereRerankClient:
return None
return cls(
api_key=config.api_key,
- model=config.model_name
- if config.model_name != "doubao-seed-rerank"
- else "rerank-v3.5",
+ model=config.model_name if config.model_name != "doubao-seed-rerank" else "rerank-v3.5",
)
diff --git a/openviking_cli/utils/rerank_litellm.py b/openviking/models/rerank/litellm_rerank.py
similarity index 85%
rename from openviking_cli/utils/rerank_litellm.py
rename to openviking/models/rerank/litellm_rerank.py
index ab8cc57d0..c41bbe473 100644
--- a/openviking_cli/utils/rerank_litellm.py
+++ b/openviking/models/rerank/litellm_rerank.py
@@ -4,14 +4,16 @@
LiteLLM Rerank API Client.
"""
+# For logging, use Python's built-in logging
+import logging
from typing import List, Optional
-from openviking_cli.utils.logger import get_logger
+from openviking.models.rerank.base import RerankBase
-logger = get_logger(__name__)
+logger = logging.getLogger(__name__)
-class LiteLLMRerankClient:
+class LiteLLMRerankClient(RerankBase):
"""
LiteLLM rerank API client.
"""
@@ -25,9 +27,11 @@ class LiteLLMRerankClient:
api_base: API base for LiteLLM providers (optional, can come from env)
model_name: Model name to use for reranking
"""
+ super().__init__()
self.api_key = api_key
self.api_base = api_base
self.model_name = model_name
+ self.provider = "litellm"
def rerank_batch(self, query: str, documents: List[str]) -> Optional[List[float]]:
"""
@@ -55,6 +59,12 @@ class LiteLLMRerankClient:
api_base=self.api_base,
)
+ # Update token usage tracking (estimate from response or input)
+ response_dict = (
+ response.model_dump() if hasattr(response, "model_dump") else response.__dict__
+ )
+ self._extract_and_update_token_usage(response_dict, query, documents)
+
results = response.results
if not results:
logger.warning(f"[LiteLLMRerankClient] Unexpected response format: {response}")
diff --git a/openviking_cli/utils/rerank_openai.py b/openviking/models/rerank/openai_rerank.py
similarity index 90%
rename from openviking_cli/utils/rerank_openai.py
rename to openviking/models/rerank/openai_rerank.py
index bdcc191b7..0760cb339 100644
--- a/openviking_cli/utils/rerank_openai.py
+++ b/openviking/models/rerank/openai_rerank.py
@@ -7,16 +7,18 @@ Supports third-party rerank services like Alibaba Cloud DashScope (qwen3-rerank)
via api_key + api_base configuration.
"""
+# For logging, use Python's built-in logging
+import logging
from typing import List, Optional
import requests
-from openviking_cli.utils.logger import get_logger
+from openviking.models.rerank.base import RerankBase
-logger = get_logger(__name__)
+logger = logging.getLogger(__name__)
-class OpenAIRerankClient:
+class OpenAIRerankClient(RerankBase):
"""
OpenAI-compatible rerank API client using Bearer token auth.
@@ -32,9 +34,11 @@ class OpenAIRerankClient:
api_base: Full endpoint URL for the rerank API
model_name: Model name to use for reranking
"""
+ super().__init__()
self.api_key = api_key
self.api_base = api_base
self.model_name = model_name
+ self.provider = "openai"
def rerank_batch(self, query: str, documents: List[str]) -> Optional[List[float]]:
"""
@@ -70,6 +74,9 @@ class OpenAIRerankClient:
response.raise_for_status()
result = response.json()
+ # Update token usage tracking (estimate, OpenAI rerank doesn't provide token info)
+ self._extract_and_update_token_usage(result, query, documents)
+
# Standard OpenAI/Cohere rerank format: results[].{index, relevance_score}
results = result.get("results")
if not results:
diff --git a/openviking_cli/utils/rerank.py b/openviking/models/rerank/volcengine_rerank.py
similarity index 87%
rename from openviking_cli/utils/rerank.py
rename to openviking/models/rerank/volcengine_rerank.py
index 663a959aa..88d61cbce 100644
--- a/openviking_cli/utils/rerank.py
+++ b/openviking/models/rerank/volcengine_rerank.py
@@ -7,6 +7,9 @@ Provides rerank functionality for hierarchical retrieval.
"""
import json
+
+# For logging, use Python's built-in logging
+import logging
from typing import List, Optional
import requests
@@ -14,12 +17,12 @@ from volcengine.auth.SignerV4 import SignerV4
from volcengine.base.Request import Request
from volcengine.Credentials import Credentials
-from openviking_cli.utils.logger import get_logger
+from openviking.models.rerank.base import RerankBase
-logger = get_logger(__name__)
+logger = logging.getLogger(__name__)
-class RerankClient:
+class RerankClient(RerankBase):
"""
VikingDB Rerank API client.
@@ -44,11 +47,13 @@ class RerankClient:
model_name: Rerank model name
model_version: Rerank model version
"""
+ super().__init__()
self.ak = ak
self.sk = sk
self.host = host
self.model_name = model_name
self.model_version = model_version
+ self.provider = "vikingdb"
def _prepare_request(
self,
@@ -89,7 +94,7 @@ class RerankClient:
Returns:
List of rerank scores for each document (same order as input),
- or None when rerank fails and the caller should fall back
+ or None when rerankver fails and the caller should fall back
"""
if not documents:
return []
@@ -124,6 +129,9 @@ class RerankClient:
logger.warning(f"[RerankClient] Unexpected response format: {result}")
return None
+ # Update token usage tracking (estimate, VikingDB doesn't provide token info)
+ self._extract_and_update_token_usage(result, query, documents)
+
# Each document is a separate group, data array returns scores for each group sequentially
data = result["result"]["data"]
if len(data) != len(documents):
@@ -159,17 +167,17 @@ class RerankClient:
provider = config._effective_provider()
if provider == "cohere":
- from openviking_cli.utils.cohere_rerank import CohereRerankClient
+ from openviking.models.rerank.cohere_rerank import CohereRerankClient
return CohereRerankClient.from_config(config)
if provider == "litellm":
- from openviking_cli.utils.rerank_litellm import LiteLLMRerankClient
+ from openviking.models.rerank.litellm_rerank import LiteLLMRerankClient
return LiteLLMRerankClient.from_config(config)
if provider == "openai":
- from openviking_cli.utils.rerank_openai import OpenAIRerankClient
+ from openviking.models.rerank.openai_rerank import OpenAIRerankClient
return OpenAIRerankClient.from_config(config)
diff --git a/openviking/models/vlm/token_usage.py b/openviking/models/vlm/token_usage.py
index f4cce7bd8..26d736281 100644
--- a/openviking/models/vlm/token_usage.py
+++ b/openviking/models/vlm/token_usage.py
@@ -16,6 +16,7 @@ class TokenUsage:
prompt_tokens: int = 0
completion_tokens: int = 0
total_tokens: int = 0
+ call_count: int = 0
last_updated: datetime = field(default_factory=datetime.now)
def update(self, prompt_tokens: int, completion_tokens: int) -> None:
@@ -28,6 +29,7 @@ class TokenUsage:
self.prompt_tokens += prompt_tokens
self.completion_tokens += completion_tokens
self.total_tokens = self.prompt_tokens + self.completion_tokens
+ self.call_count += 1
self.last_updated = datetime.now()
def reset(self) -> None:
@@ -35,6 +37,7 @@ class TokenUsage:
self.prompt_tokens = 0
self.completion_tokens = 0
self.total_tokens = 0
+ self.call_count = 0
self.last_updated = datetime.now()
def to_dict(self) -> Dict:
@@ -47,6 +50,7 @@ class TokenUsage:
"prompt_tokens": self.prompt_tokens,
"completion_tokens": self.completion_tokens,
"total_tokens": self.total_tokens,
+ "call_count": self.call_count,
"last_updated": format_iso8601(self.last_updated),
}
@@ -54,7 +58,8 @@ class TokenUsage:
return (
f"TokenUsage(prompt={self.prompt_tokens}, "
f"completion={self.completion_tokens}, "
- f"total={self.total_tokens})"
+ f"total={self.total_tokens}, "
+ f"calls={self.call_count})"
)
diff --git a/openviking/parse/ovpack/__init__.py b/openviking/parse/ovpack/__init__.py
deleted file mode 100644
index 236633478..000000000
--- a/openviking/parse/ovpack/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
diff --git a/openviking/retrieve/hierarchical_retriever.py b/openviking/retrieve/hierarchical_retriever.py
index 1fbe4d468..3192ccff8 100644
--- a/openviking/retrieve/hierarchical_retriever.py
+++ b/openviking/retrieve/hierarchical_retriever.py
@@ -15,6 +15,7 @@ from datetime import datetime
from typing import Any, Dict, List, Optional, Tuple
from openviking.models.embedder.base import EmbedResult
+from openviking.models.rerank import RerankClient
from openviking.retrieve.memory_lifecycle import hotness_score
from openviking.retrieve.retrieval_stats import get_stats_collector
from openviking.server.identity import RequestContext, Role
@@ -31,7 +32,6 @@ from openviking_cli.retrieve.types import (
)
from openviking_cli.utils.config import RerankConfig
from openviking_cli.utils.logger import get_logger
-from openviking_cli.utils.rerank import RerankClient
logger = get_logger(__name__)
@@ -272,7 +272,7 @@ class HierarchicalRetriever:
return fallback_scores
normalized_scores: List[float] = []
- for score, fallback in zip(scores, fallback_scores):
+ for score, fallback in zip(scores, fallback_scores, strict=True):
if isinstance(score, (int, float)):
normalized_scores.append(float(score))
else:
@@ -343,7 +343,7 @@ class HierarchicalRetriever:
else:
query_scores = default_scores
- for candidate, score in zip(initial_candidates, query_scores):
+ for candidate, score in zip(initial_candidates, query_scores, strict=True):
candidate["_score"] = score
return initial_candidates
@@ -444,7 +444,7 @@ class HierarchicalRetriever:
documents = [str(r.get("abstract", "")) for r in results]
query_scores = self._rerank_scores(query, documents, query_scores)
- for r, score in zip(results, query_scores):
+ for r, score in zip(results, query_scores, strict=True):
uri = r.get("uri", "")
final_score = (
alpha * score + (1 - alpha) * current_score if current_score else score
diff --git a/openviking/server/routers/observer.py b/openviking/server/routers/observer.py
index ef8e1ea3c..e2c626c25 100644
--- a/openviking/server/routers/observer.py
+++ b/openviking/server/routers/observer.py
@@ -3,10 +3,10 @@
"""Observer endpoints for OpenViking HTTP Server.
Provides observability API for monitoring component status.
-Mirrors the SDK's client.observer API:
+Mirrors SDK's client.observer API:
- /api/v1/observer/queue - Queue status
- /api/v1/observer/vikingdb - VikingDB status
-- /api/v1/observer/vlm - VLM status
+- /api/v1/observer/models - Models status (VLM, Embedding, Rerank)
- /api/v1/observer/system - System overall status
"""
@@ -62,13 +62,13 @@ async def observer_vikingdb(
return Response(status="ok", result=_component_to_dict(component))
-async def observer_vlm(
+async def observer_models(
_ctx: RequestContext = Depends(get_request_context),
):
- """Get VLM (Vision Language Model) token usage status."""
+ """Get models status (VLM, Embedding, Rerank)."""
service = get_service()
- component = service.debug.observer.vlm
+ component = service.debug.observer.models
return Response(status="ok", result=_component_to_dict(component))
diff --git a/openviking/service/debug_service.py b/openviking/service/debug_service.py
index cc84c8f0f..955f97d61 100644
--- a/openviking/service/debug_service.py
+++ b/openviking/service/debug_service.py
@@ -11,10 +11,10 @@ from openviking.server.identity import RequestContext
from openviking.storage import VikingDBManager
from openviking.storage.observers import (
LockObserver,
+ ModelsObserver,
QueueObserver,
RetrievalObserver,
VikingDBObserver,
- VLMObserver,
)
from openviking.storage.queuefs import get_queue_manager
from openviking.storage.transaction import get_lock_manager
@@ -118,18 +118,37 @@ class ObserverService:
)
@property
- def vlm(self) -> ComponentStatus:
- """Get VLM status."""
+ def models(self) -> ComponentStatus:
+ """Get Models status (VLM, Embedding, Rerank)."""
if self._config is None:
return ComponentStatus(
- name="vlm",
+ name="models",
is_healthy=False,
has_errors=True,
status="Not initialized",
)
- observer = VLMObserver(self._config.vlm.get_vlm_instance())
+
+ vlm_instance = self._config.vlm.get_vlm_instance()
+ embedding_instance = None
+ rerank_instance = None
+
+ # Get embedding instance if available
+ if self._config.embedding:
+ embedding_instance = self._config.embedding.get_embedder()
+
+ # Get rerank instance if available
+ if self._config.rerank and self._config.rerank.is_available():
+ from openviking.models.rerank import RerankClient
+
+ rerank_instance = RerankClient.from_config(self._config.rerank)
+
+ observer = ModelsObserver(
+ vlm_instance=vlm_instance,
+ embedding_instance=embedding_instance,
+ rerank_instance=rerank_instance,
+ )
return ComponentStatus(
- name="vlm",
+ name="models",
is_healthy=observer.is_healthy(),
has_errors=observer.has_errors(),
status=observer.get_status_table(),
@@ -171,7 +190,7 @@ class ObserverService:
components = {
"queue": self.queue,
"vikingdb": self.vikingdb(ctx=ctx),
- "vlm": self.vlm,
+ "models": self.models,
"lock": self.lock,
"retrieval": self.retrieval,
}
diff --git a/openviking/storage/observers/__init__.py b/openviking/storage/observers/__init__.py
index cc657ddd9..c8b643c6b 100644
--- a/openviking/storage/observers/__init__.py
+++ b/openviking/storage/observers/__init__.py
@@ -2,6 +2,7 @@
# SPDX-License-Identifier: AGPL-3.0
from .base_observer import BaseObserver
from .lock_observer import LockObserver
+from .models_observer import ModelsObserver
from .prometheus_observer import (
PrometheusObserver,
get_prometheus_observer,
@@ -10,16 +11,15 @@ from .prometheus_observer import (
from .queue_observer import QueueObserver
from .retrieval_observer import RetrievalObserver
from .vikingdb_observer import VikingDBObserver
-from .vlm_observer import VLMObserver
__all__ = [
"BaseObserver",
"LockObserver",
+ "ModelsObserver",
"PrometheusObserver",
"get_prometheus_observer",
"set_prometheus_observer",
"QueueObserver",
"RetrievalObserver",
"VikingDBObserver",
- "VLMObserver",
]
diff --git a/openviking/storage/observers/models_observer.py b/openviking/storage/observers/models_observer.py
new file mode 100644
index 000000000..3c5736d60
--- /dev/null
+++ b/openviking/storage/observers/models_observer.py
@@ -0,0 +1,219 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+"""
+ModelsObserver: Multi-model system observability tool.
+
+Provides methods to observe and report token usage across VLM, Embedding, and Rerank models.
+"""
+
+from typing import Any, Optional
+
+from openviking.storage.observers.base_observer import BaseObserver
+from openviking_cli.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ModelsObserver(BaseObserver):
+ """
+ ModelsObserver: System observability tool for multi-model token usage monitoring.
+
+ Provides methods to query token usage status and format output for VLM, Embedding, and Rerank models.
+ """
+
+ def __init__(
+ self,
+ vlm_instance: Optional[Any] = None,
+ embedding_instance: Optional[Any] = None,
+ rerank_instance: Optional[Any] = None,
+ ):
+ """
+ Initialize ModelsObserver with model instances.
+
+ Args:
+ vlm_instance: VLM instance to observe (optional)
+ embedding_instance: Embedding instance to observe (optional)
+ rerank_instance: Rerank instance to observe (optional)
+ """
+ self._vlm_instance = vlm_instance
+ self._embedding_instance = embedding_instance
+ self._rerank_instance = rerank_instance
+
+ def get_status_table(self) -> str:
+ """
+ Format token usage status as a string table.
+
+ Returns:
+ Formatted table string representation of token usage for all models
+ """
+ return self._format_status_as_table()
+
+ def _format_status_as_table(self) -> str:
+ """
+ Format token usage status as a table using tabulate.
+
+ Returns:
+ Formatted table string representation of token usage for all models
+ """
+ from tabulate import tabulate
+
+ sections = []
+
+ # VLM section
+ if self._vlm_instance:
+ try:
+ vlm_data = self._get_vlm_usage()
+ if vlm_data:
+ sections.append(("VLM", vlm_data))
+ except Exception as e:
+ logger.warning(f"Error getting VLM usage: {e}")
+
+ # Embedding section
+ if self._embedding_instance:
+ try:
+ embedding_data = self._get_embedding_usage()
+ if embedding_data:
+ sections.append(("Embedding", embedding_data))
+ except Exception as e:
+ logger.warning(f"Error getting Embedding usage: {e}")
+
+ # Rerank section
+ if self._rerank_instance:
+ try:
+ rerank_data = self._get_rerank_usage()
+ if rerank_data:
+ sections.append(("Rerank", rerank_data))
+ except Exception as e:
+ logger.warning(f"Error getting Rerank usage: {e}")
+
+ if not sections:
+ return "No model usage data available."
+
+ # Format output
+ lines = []
+ for model_type, data in sections:
+ lines.append(f"\n{model_type} Models:")
+ lines.append(tabulate(data, headers="keys", tablefmt="pretty"))
+ lines.append("")
+
+ return "\n".join(lines)
+
+ def _get_vlm_usage(self) -> Optional[list]:
+ """Get VLM token usage data."""
+ if not self._vlm_instance:
+ return None
+
+ usage_data = self._vlm_instance.get_token_usage()
+
+ if not usage_data.get("usage_by_model"):
+ return None
+
+ data = []
+ for model_name, model_data in usage_data["usage_by_model"].items():
+ for provider_name, provider_data in model_data["usage_by_provider"].items():
+ data.append(
+ {
+ "Model": model_name,
+ "Provider": provider_name,
+ "Calls": provider_data.get("call_count", 0),
+ "Prompt": provider_data["prompt_tokens"],
+ "Completion": provider_data["completion_tokens"],
+ "Total": provider_data["total_tokens"],
+ "Last Updated": provider_data["last_updated"],
+ }
+ )
+
+ return data
+
+ def _get_embedding_usage(self) -> Optional[list]:
+ """Get Embedding token usage data."""
+ if not self._embedding_instance:
+ return None
+
+ if hasattr(self._embedding_instance, "get_token_usage"):
+ usage_data = self._embedding_instance.get_token_usage()
+ elif hasattr(self._embedding_instance, "_token_tracker"):
+ usage_data = self._embedding_instance._token_tracker.to_dict()
+ else:
+ return None
+
+ if not usage_data.get("usage_by_model"):
+ return None
+
+ data = []
+ for model_name, model_data in usage_data["usage_by_model"].items():
+ for provider_name, provider_data in model_data["usage_by_provider"].items():
+ data.append(
+ {
+ "Model": model_name,
+ "Provider": provider_name,
+ "Calls": provider_data.get("call_count", 0),
+ "Prompt": provider_data["prompt_tokens"],
+ "Completion": provider_data["completion_tokens"],
+ "Total": provider_data["total_tokens"],
+ "Last Updated": provider_data["last_updated"],
+ }
+ )
+
+ return data
+
+ def _get_rerank_usage(self) -> Optional[list]:
+ """Get Rerank token usage data."""
+ if not self._rerank_instance:
+ return None
+
+ if hasattr(self._rerank_instance, "get_token_usage"):
+ usage_data = self._rerank_instance.get_token_usage()
+ elif hasattr(self._rerank_instance, "_token_tracker"):
+ usage_data = self._rerank_instance._token_tracker.to_dict()
+ else:
+ return None
+
+ if not usage_data.get("usage_by_model"):
+ return None
+
+ data = []
+ for model_name, model_data in usage_data["usage_by_model"].items():
+ for provider_name, provider_data in model_data["usage_by_provider"].items():
+ data.append(
+ {
+ "Model": model_name,
+ "Provider": provider_name,
+ "Calls": provider_data.get("call_count", 0),
+ "Prompt": provider_data["prompt_tokens"],
+ "Completion": provider_data["completion_tokens"],
+ "Total": provider_data["total_tokens"],
+ "Last Updated": provider_data["last_updated"],
+ }
+ )
+
+ return data
+
+ def __str__(self) -> str:
+ return self.get_status_table()
+
+ def is_healthy(self) -> bool:
+ """
+ Check if model system is healthy.
+
+ For ModelsObserver, healthy means at least one model is available and token tracking is working.
+
+ Returns:
+ True if system is healthy, False otherwise
+ """
+ return (
+ self._vlm_instance is not None
+ or self._embedding_instance is not None
+ or self._rerank_instance is not None
+ )
+
+ def has_errors(self) -> bool:
+ """
+ Check if model system has any errors.
+
+ For ModelsObserver, errors are not tracked in token usage.
+
+ Returns:
+ False (no error tracking in token usage)
+ """
+ return False
diff --git a/openviking/storage/observers/vlm_observer.py b/openviking/storage/observers/vlm_observer.py
deleted file mode 100644
index 20af3273f..000000000
--- a/openviking/storage/observers/vlm_observer.py
+++ /dev/null
@@ -1,116 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-"""
-VLMObserver: VLM system observability tool.
-
-Provides methods to observe and report token usage across VLM models and backends.
-"""
-
-from openviking.models.vlm.base import VLMBase
-from openviking.storage.observers.base_observer import BaseObserver
-from openviking_cli.utils.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class VLMObserver(BaseObserver):
- """
- VLMObserver: System observability tool for VLM token usage monitoring.
-
- Provides methods to query token usage status and format output.
- """
-
- def __init__(self, vlm_instance: VLMBase):
- """
- Initialize VLMObserver with a VLM instance.
-
- Args:
- vlm_instance: VLMBase instance to observe
- """
- self._vlm_instance = vlm_instance
-
- def get_status_table(self) -> str:
- """
- Format token usage status as a string table.
-
- Returns:
- Formatted table string representation of token usage
- """
- return self._format_status_as_table()
-
- def _format_status_as_table(self) -> str:
- """
- Format token usage status as a table using tabulate.
-
- Returns:
- Formatted table string representation of token usage
- """
- from tabulate import tabulate
-
- usage_data = self._vlm_instance.get_token_usage()
-
- if not usage_data.get("usage_by_model"):
- return "No token usage data available."
-
- data = []
- total_prompt = 0
- total_completion = 0
- total_all = 0
-
- for model_name, model_data in usage_data["usage_by_model"].items():
- for provider_name, provider_data in model_data["usage_by_provider"].items():
- data.append(
- {
- "Model": model_name,
- "Provider": provider_name,
- "Prompt": provider_data["prompt_tokens"],
- "Completion": provider_data["completion_tokens"],
- "Total": provider_data["total_tokens"],
- "Last Updated": provider_data["last_updated"],
- }
- )
- total_prompt += provider_data["prompt_tokens"]
- total_completion += provider_data["completion_tokens"]
- total_all += provider_data["total_tokens"]
-
- if not data:
- return "No token usage data available."
-
- # Add total row
- data.append(
- {
- "Model": "TOTAL",
- "Provider": "",
- "Prompt": total_prompt,
- "Completion": total_completion,
- "Total": total_all,
- "Last Updated": "",
- }
- )
-
- return tabulate(data, headers="keys", tablefmt="pretty")
-
- def __str__(self) -> str:
- return self.get_status_table()
-
- def is_healthy(self) -> bool:
- """
- Check if VLM system is healthy.
-
- For VLMObserver, healthy means token tracking is enabled and working.
-
- Returns:
- True if system is healthy, False otherwise
- """
- return True # Token tracking doesn't have a health state
-
- def has_errors(self) -> bool:
- """
- Check if VLM system has any errors.
-
- For VLMObserver, errors are not tracked in token usage.
-
- Returns:
- False (no error tracking in token usage)
- """
- return False
diff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.py
index 93a800f03..5b1fb9a9a 100644
--- a/openviking_cli/client/http.py
+++ b/openviking_cli/client/http.py
@@ -77,9 +77,9 @@ class _HTTPObserver:
"""Fetch VikingDB status asynchronously."""
return await self._client._get_vikingdb_status()
- async def _fetch_vlm_status(self) -> Dict[str, Any]:
- """Fetch VLM status asynchronously."""
- return await self._client._get_vlm_status()
+ async def _fetch_models_status(self) -> Dict[str, Any]:
+ """Fetch models status asynchronously."""
+ return await self._client._get_models_status()
async def _fetch_system_status(self) -> Dict[str, Any]:
"""Fetch system status asynchronously."""
@@ -96,9 +96,9 @@ class _HTTPObserver:
return run_async(self._fetch_vikingdb_status())
@property
- def vlm(self) -> Dict[str, Any]:
- """Get VLM status (sync wrapper)."""
- return run_async(self._fetch_vlm_status())
+ def models(self) -> Dict[str, Any]:
+ """Get models status (VLM, Embedding, Rerank) (sync wrapper)."""
+ return run_async(self._fetch_models_status())
@property
def system(self) -> Dict[str, Any]:
@@ -884,9 +884,9 @@ class AsyncHTTPClient(BaseClient):
response = await self._http.get("/api/v1/observer/vikingdb")
return self._handle_response(response)
- async def _get_vlm_status(self) -> Dict[str, Any]:
- """Get VLM status (internal for _HTTPObserver)."""
- response = await self._http.get("/api/v1/observer/vlm")
+ async def _get_models_status(self) -> Dict[str, Any]:
+ """Get models status (VLM, Embedding, Rerank) (internal for _HTTPObserver)."""
+ response = await self._http.get("/api/v1/observer/models")
return self._handle_response(response)
async def _get_system_status(self) -> Dict[str, Any]:
diff --git a/pyproject.toml b/pyproject.toml
index 003d1e1dc..4c9e9d54a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -92,6 +92,7 @@ test = [
dev = [
"mypy>=1.0.0",
"ruff>=0.1.0",
+ "setuptools_scm>=10.0.0",
]
doc = [
"sphinx>=7.0.0",
diff --git a/tests/misc/test_debug_service.py b/tests/misc/test_debug_service.py
index fb7f1b36e..90de9062d 100644
--- a/tests/misc/test_debug_service.py
+++ b/tests/misc/test_debug_service.py
@@ -175,61 +175,95 @@ class TestObserverService:
assert status.status == "VikingDB Status Table"
mock_observer_cls.assert_called_once_with(mock_vikingdb)
- @patch("openviking.service.debug_service.VLMObserver")
- def test_vlm_property(self, mock_observer_cls):
- """Test vlm property returns ComponentStatus."""
- mock_config = MagicMock()
+ @patch("openviking.service.debug_service.ModelsObserver")
+ def test_models_property(self, mock_observer_cls):
+ """Test models property returns ComponentStatus."""
+ mock_config = MagicMock(spec=["vlm"]) # Only allow vlm attribute
mock_vlm_instance = MagicMock()
mock_config.vlm.get_vlm_instance.return_value = mock_vlm_instance
mock_observer = MagicMock()
mock_observer.is_healthy.return_value = True
mock_observer.has_errors.return_value = False
- mock_observer.get_status_table.return_value = "VLM Status Table"
+ mock_observer.get_status_table.return_value = "Models Status Table"
mock_observer_cls.return_value = mock_observer
service = ObserverService(config=mock_config)
- status = service.vlm
+ status = service.models
assert isinstance(status, ComponentStatus)
- assert status.name == "vlm"
+ assert status.name == "models"
assert status.is_healthy is True
assert status.has_errors is False
- assert status.status == "VLM Status Table"
- mock_observer_cls.assert_called_once_with(mock_vlm_instance)
+ assert status.status == "Models Status Table"
+ mock_observer_cls.assert_called_once_with(
+ vlm_instance=mock_vlm_instance,
+ embedding_instance=None,
+ rerank_instance=None,
+ )
- @patch("openviking.service.debug_service.get_queue_manager")
- @patch("openviking.service.debug_service.QueueObserver")
+ @patch("openviking.service.debug_service.get_lock_manager")
+ @patch("openviking.service.debug_service.RetrievalObserver")
+ @patch("openviking.service.debug_service.LockObserver")
+ @patch("openviking.service.debug_service.ModelsObserver")
@patch("openviking.service.debug_service.VikingDBObserver")
- @patch("openviking.service.debug_service.VLMObserver")
+ @patch("openviking.service.debug_service.QueueObserver")
+ @patch("openviking.service.debug_service.get_queue_manager")
def test_system_property_all_healthy(
- self, mock_vlm_cls, mock_vikingdb_cls, mock_queue_cls, mock_get_queue_manager
+ self,
+ mock_get_queue_mgr,
+ mock_queue_cls,
+ mock_vikingdb_cls,
+ mock_models_cls,
+ mock_lock_cls,
+ mock_retrieval_cls,
+ mock_get_lock_mgr,
):
"""Test system property when all components are healthy."""
# Setup mocks
- for mock_cls in [mock_queue_cls, mock_vikingdb_cls, mock_vlm_cls]:
+ for mock_cls in [
+ mock_queue_cls,
+ mock_vikingdb_cls,
+ mock_models_cls,
+ mock_lock_cls,
+ mock_retrieval_cls,
+ ]:
mock_observer = MagicMock()
mock_observer.is_healthy.return_value = True
mock_observer.has_errors.return_value = False
mock_observer.get_status_table.return_value = "OK"
mock_cls.return_value = mock_observer
- mock_config = MagicMock()
+ # Mock get_lock_manager to return a MagicMock
+ mock_get_lock_mgr.return_value = MagicMock()
+
+ mock_config = MagicMock(spec=["vlm"]) # Only allow vlm attribute
+ mock_config.vlm.get_vlm_instance.return_value = MagicMock()
service = ObserverService(vikingdb=MagicMock(), config=mock_config)
status = service.system()
assert isinstance(status, SystemStatus)
- for name in ("queue", "vikingdb", "vlm"):
+ for name in ("queue", "vikingdb", "models", "lock", "retrieval"):
assert status.components[name].is_healthy is True
non_transaction_errors = [e for e in status.errors if "transaction" not in e]
assert non_transaction_errors == []
- @patch("openviking.service.debug_service.get_queue_manager")
- @patch("openviking.service.debug_service.QueueObserver")
+ @patch("openviking.service.debug_service.get_lock_manager")
+ @patch("openviking.service.debug_service.RetrievalObserver")
+ @patch("openviking.service.debug_service.LockObserver")
+ @patch("openviking.service.debug_service.ModelsObserver")
@patch("openviking.service.debug_service.VikingDBObserver")
- @patch("openviking.service.debug_service.VLMObserver")
+ @patch("openviking.service.debug_service.QueueObserver")
+ @patch("openviking.service.debug_service.get_queue_manager")
def test_system_property_with_errors(
- self, mock_vlm_cls, mock_vikingdb_cls, mock_queue_cls, mock_get_queue_manager
+ self,
+ mock_get_queue_mgr,
+ mock_queue_cls,
+ mock_vikingdb_cls,
+ mock_models_cls,
+ mock_lock_cls,
+ mock_retrieval_cls,
+ mock_get_lock_mgr,
):
"""Test system property when some components have errors."""
# Queue has errors
@@ -246,14 +280,26 @@ class TestObserverService:
mock_vikingdb.get_status_table.return_value = "OK"
mock_vikingdb_cls.return_value = mock_vikingdb
- # VLM has errors
- mock_vlm = MagicMock()
- mock_vlm.is_healthy.return_value = False
- mock_vlm.has_errors.return_value = True
- mock_vlm.get_status_table.return_value = "Error"
- mock_vlm_cls.return_value = mock_vlm
+ # Models has errors
+ mock_models = MagicMock()
+ mock_models.is_healthy.return_value = False
+ mock_models.has_errors.return_value = True
+ mock_models.get_status_table.return_value = "Error"
+ mock_models_cls.return_value = mock_models
- mock_config = MagicMock()
+ # Lock and Retrieval are healthy
+ for mock_cls in [mock_lock_cls, mock_retrieval_cls]:
+ mock_observer = MagicMock()
+ mock_observer.is_healthy.return_value = True
+ mock_observer.has_errors.return_value = False
+ mock_observer.get_status_table.return_value = "OK"
+ mock_cls.return_value = mock_observer
+
+ # Mock get_lock_manager to return a MagicMock
+ mock_get_lock_mgr.return_value = MagicMock()
+
+ mock_config = MagicMock(spec=["vlm"]) # Only allow vlm attribute
+ mock_config.vlm.get_vlm_instance.return_value = MagicMock()
service = ObserverService(vikingdb=MagicMock(), config=mock_config)
status = service.system()
@@ -262,24 +308,33 @@ class TestObserverService:
non_transaction_errors = [e for e in status.errors if "transaction" not in e]
assert len(non_transaction_errors) == 2
assert "queue has errors" in non_transaction_errors
- assert "vlm has errors" in non_transaction_errors
+ assert "models has errors" in non_transaction_errors
+ @patch("openviking.service.debug_service.get_lock_manager")
@patch("openviking.service.debug_service.get_queue_manager")
@patch("openviking.service.debug_service.QueueObserver")
@patch("openviking.service.debug_service.VikingDBObserver")
- @patch("openviking.service.debug_service.VLMObserver")
+ @patch("openviking.service.debug_service.ModelsObserver")
def test_is_healthy_returns_true(
- self, mock_vlm_cls, mock_vikingdb_cls, mock_queue_cls, mock_get_queue_manager
+ self,
+ mock_models_cls,
+ mock_vikingdb_cls,
+ mock_queue_cls,
+ mock_get_queue_mgr,
+ mock_get_lock_mgr,
):
"""Test is_healthy returns True when system is healthy."""
- for mock_cls in [mock_queue_cls, mock_vikingdb_cls, mock_vlm_cls]:
+ for mock_cls in [mock_queue_cls, mock_vikingdb_cls, mock_models_cls]:
mock_observer = MagicMock()
mock_observer.is_healthy.return_value = True
mock_observer.has_errors.return_value = False
mock_observer.get_status_table.return_value = "OK"
mock_cls.return_value = mock_observer
- mock_config = MagicMock()
+ mock_get_lock_mgr.return_value = MagicMock()
+
+ mock_config = MagicMock(spec=["vlm"])
+ mock_config.vlm.get_vlm_instance.return_value = MagicMock()
service = ObserverService(vikingdb=MagicMock(), config=mock_config)
status = service.system()
assert all(c.is_healthy for name, c in status.components.items() if name != "transaction")
@@ -299,12 +354,12 @@ class TestObserverService:
assert status.has_errors is True
assert status.status == "Not initialized"
- def test_vlm_property_without_dependency(self):
- """Test vlm property returns unhealthy ComponentStatus when config is None."""
+ def test_models_property_without_dependency(self):
+ """Test models property returns unhealthy ComponentStatus when config is None."""
service = ObserverService()
- status = service.vlm
+ status = service.models
assert isinstance(status, ComponentStatus)
- assert status.name == "vlm"
+ assert status.name == "models"
assert status.is_healthy is False
assert status.has_errors is True
assert status.status == "Not initialized"
@@ -319,9 +374,9 @@ class TestObserverService:
@patch("openviking.service.debug_service.get_queue_manager")
@patch("openviking.service.debug_service.QueueObserver")
@patch("openviking.service.debug_service.VikingDBObserver")
- @patch("openviking.service.debug_service.VLMObserver")
+ @patch("openviking.service.debug_service.ModelsObserver")
def test_is_healthy_returns_false(
- self, mock_vlm_cls, mock_vikingdb_cls, mock_queue_cls, mock_get_queue_manager
+ self, mock_models_cls, mock_vikingdb_cls, mock_queue_cls, mock_get_queue_manager
):
"""Test is_healthy returns False when system is unhealthy."""
# Queue has errors
@@ -332,14 +387,15 @@ class TestObserverService:
mock_queue_cls.return_value = mock_queue
# Others are healthy
- for mock_cls in [mock_vikingdb_cls, mock_vlm_cls]:
+ for mock_cls in [mock_vikingdb_cls, mock_models_cls]:
mock_observer = MagicMock()
mock_observer.is_healthy.return_value = True
mock_observer.has_errors.return_value = False
mock_observer.get_status_table.return_value = "OK"
mock_cls.return_value = mock_observer
- mock_config = MagicMock()
+ mock_config = MagicMock(spec=["vlm"]) # Only allow vlm attribute
+ mock_config.vlm.get_vlm_instance.return_value = MagicMock()
service = ObserverService(vikingdb=MagicMock(), config=mock_config)
assert service.is_healthy() is False
diff --git a/tests/misc/test_rerank_openai.py b/tests/misc/test_rerank_openai.py
index 6a0c55f99..b835950ef 100644
--- a/tests/misc/test_rerank_openai.py
+++ b/tests/misc/test_rerank_openai.py
@@ -7,9 +7,8 @@ from unittest.mock import MagicMock, patch
import pytest
from pydantic import ValidationError
+from openviking.models.rerank import OpenAIRerankClient, RerankClient
from openviking_cli.utils.config.rerank_config import RerankConfig
-from openviking_cli.utils.rerank import RerankClient
-from openviking_cli.utils.rerank_openai import OpenAIRerankClient
class TestOpenAIRerankClient:
@@ -32,7 +31,9 @@ class TestOpenAIRerankClient:
}
mock_response.raise_for_status = MagicMock()
- with patch("openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response):
+ with patch(
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
+ ):
scores = client.rerank_batch("test query", ["doc1", "doc2", "doc3"])
assert scores == [0.9, 0.3, 0.7]
@@ -50,7 +51,9 @@ class TestOpenAIRerankClient:
}
mock_response.raise_for_status = MagicMock()
- with patch("openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response):
+ with patch(
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
+ ):
scores = client.rerank_batch("test query", ["doc1", "doc2", "doc3"])
assert scores == [0.9, 0.3, 0.7]
@@ -66,7 +69,9 @@ class TestOpenAIRerankClient:
mock_response.json.return_value = {"unexpected": "format"}
mock_response.raise_for_status = MagicMock()
- with patch("openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response):
+ with patch(
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
+ ):
result = client.rerank_batch("query", ["doc1"])
assert result is None
@@ -81,7 +86,9 @@ class TestOpenAIRerankClient:
}
mock_response.raise_for_status = MagicMock()
- with patch("openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response):
+ with patch(
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
+ ):
result = client.rerank_batch("query", ["doc1", "doc2"])
assert result is None
@@ -97,7 +104,9 @@ class TestOpenAIRerankClient:
}
mock_response.raise_for_status = MagicMock()
- with patch("openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response):
+ with patch(
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
+ ):
result = client.rerank_batch("query", ["doc1"])
assert result is None
@@ -113,7 +122,9 @@ class TestOpenAIRerankClient:
}
mock_response.raise_for_status = MagicMock()
- with patch("openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response):
+ with patch(
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
+ ):
result = client.rerank_batch("query", ["doc1"])
assert result is None
@@ -122,7 +133,7 @@ class TestOpenAIRerankClient:
client = self._make_client()
with patch(
- "openviking_cli.utils.rerank_openai.requests.post",
+ "openviking.models.rerank.openai_rerank.requests.post",
side_effect=Exception("connection error"),
):
result = client.rerank_batch("query", ["doc1"])
@@ -136,7 +147,7 @@ class TestOpenAIRerankClient:
mock_response.raise_for_status = MagicMock()
with patch(
- "openviking_cli.utils.rerank_openai.requests.post", return_value=mock_response
+ "openviking.models.rerank.openai_rerank.requests.post", return_value=mock_response
) as mock_post:
client.rerank_batch("my query", ["doc1"])
diff --git a/tests/unit/test_cohere_rerank.py b/tests/unit/test_cohere_rerank.py
index b06fd2aa7..5d68a1e95 100644
--- a/tests/unit/test_cohere_rerank.py
+++ b/tests/unit/test_cohere_rerank.py
@@ -4,15 +4,13 @@
from unittest.mock import MagicMock, patch
-import pytest
-
-from openviking_cli.utils.cohere_rerank import CohereRerankClient
+from openviking.models.rerank import CohereRerankClient
class TestCohereRerankClient:
"""Test cases for CohereRerankClient."""
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_rerank_batch_basic(self, mock_client_class):
mock_client = MagicMock()
mock_client_class.return_value = mock_client
@@ -38,12 +36,12 @@ class TestCohereRerankClient:
assert payload["documents"] == ["doc A", "doc B", "doc C"]
assert payload["return_documents"] is False
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_rerank_batch_empty(self, mock_client_class):
client = CohereRerankClient(api_key="test-key")
assert client.rerank_batch("query", []) == []
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_rerank_batch_api_error_returns_none(self, mock_client_class):
import httpx
@@ -62,7 +60,7 @@ class TestCohereRerankClient:
result = client.rerank_batch("query", ["doc"])
assert result is None
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_rerank_preserves_original_order(self, mock_client_class):
mock_client = MagicMock()
mock_client_class.return_value = mock_client
@@ -86,7 +84,7 @@ class TestCohereRerankClient:
assert scores[1] == 0.01 # "second" was index 1
assert scores[2] == 0.99 # "third" was index 2
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_close(self, mock_client_class):
mock_client = MagicMock()
mock_client_class.return_value = mock_client
@@ -130,10 +128,10 @@ class TestRerankConfig:
class TestUnifiedRerankDispatch:
"""Test that RerankClient.from_config() dispatches all providers uniformly."""
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_from_config_creates_cohere_client(self, mock_client_class):
+ from openviking.models.rerank import RerankClient
from openviking_cli.utils.config.rerank_config import RerankConfig
- from openviking_cli.utils.rerank import RerankClient
config = RerankConfig(api_key="cohere-key")
client = RerankClient.from_config(config)
@@ -141,26 +139,26 @@ class TestUnifiedRerankDispatch:
assert client.api_key == "cohere-key"
assert client.model == "rerank-v3.5"
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_from_config_cohere_explicit_provider(self, mock_client_class):
+ from openviking.models.rerank import RerankClient
from openviking_cli.utils.config.rerank_config import RerankConfig
- from openviking_cli.utils.rerank import RerankClient
config = RerankConfig(provider="cohere", api_key="key")
client = RerankClient.from_config(config)
assert isinstance(client, CohereRerankClient)
def test_from_config_returns_none_when_unavailable(self):
+ from openviking.models.rerank import RerankClient
from openviking_cli.utils.config.rerank_config import RerankConfig
- from openviking_cli.utils.rerank import RerankClient
config = RerankConfig()
assert RerankClient.from_config(config) is None
- @patch("openviking_cli.utils.cohere_rerank.httpx.Client")
+ @patch("openviking.models.rerank.cohere_rerank.httpx.Client")
def test_cohere_from_config_uses_custom_model(self, mock_client_class):
+ from openviking.models.rerank import RerankClient
from openviking_cli.utils.config.rerank_config import RerankConfig
- from openviking_cli.utils.rerank import RerankClient
config = RerankConfig(api_key="key", model_name="rerank-v4.0")
client = RerankClient.from_config(config)