Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
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.rsindex 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: boutput_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.rsindex 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 statusVikingdb,- /// Get VLM status- Vlm,+ /// Get models status (VLM, Embedding, Rerank)+ Models,/// Get transaction system statusTransaction,/// 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).awaitdiff --git a/openviking/models/embedder/base.py b/openviking/models/embedder/base.pyindex 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_syncT = 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_nameself.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()@abstractmethoddef 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 vectorsdiff --git a/openviking/models/embedder/cohere_embedders.py b/openviking/models/embedder/cohere_embedders.pyindex 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 itself._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 modelsself._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 resultexcept 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 eexcept 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 resultsexcept 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 eexcept Exception as e:raise RuntimeError(f"Cohere batch embedding failed: {e}") from ediff --git a/openviking/models/embedder/gemini_embedders.py b/openviking/models/embedder/gemini_embedders.pyindex 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 resultexcept (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 countingreturn resultsasync 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() callsresults[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.pyindex 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 resultexcept 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 resultsexcept openai.APIError as e:self._raise_task_error(e)raise RuntimeError(f"Jina API error: {e.message}") from ediff --git a/openviking/models/embedder/litellm_embedders.py b/openviking/models/embedder/litellm_embedders.pyindex 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 kwargsdef _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 telemetryget_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.pyindex 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 resultdef 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 resultsdef get_dimension(self) -> int:"""Get embedding dimension"""diff --git a/openviking/models/embedder/openai_embedders.py b/openviking/models/embedder/openai_embedders.pyindex 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 telemetryget_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.pyindex 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 resultdef 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 resultsdef 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 resultdef 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 resultsclass 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 resultdef 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 resultsdef get_dimension(self) -> int:return self.dimension if self.dimension else 2048diff --git a/openviking/models/embedder/volcengine_embedders.py b/openviking/models/embedder/volcengine_embedders.pyindex 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 telemetryget_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_baseself.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.datasparse_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.datadense_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.pyindex 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 resultexcept openai.APIError as e:raise RuntimeError(f"Voyage API error: {e.message}") from eexcept 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 resultsexcept openai.APIError as e:raise RuntimeError(f"Voyage API error: {e.message}") from eexcept Exception as e:diff --git a/openviking/models/rerank/__init__.py b/openviking/models/rerank/__init__.pynew file mode 100644index 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.pynew file mode 100644index 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.pysimilarity index 86%rename from openviking_cli/utils/cohere_rerank.pyrename to openviking/models/rerank/cohere_rerank.pyindex 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 loggingfrom typing import List, Optionalimport 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_keyself.model = modelself.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 orderscores = [0.0] * len(documents)@@ -101,7 +108,5 @@ class CohereRerankClient:return Nonereturn 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.pysimilarity index 85%rename from openviking_cli/utils/rerank_litellm.pyrename to openviking/models/rerank/litellm_rerank.pyindex 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 loggingfrom 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_keyself.api_base = api_baseself.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.resultsif 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.pysimilarity index 90%rename from openviking_cli/utils/rerank_openai.pyrename to openviking/models/rerank/openai_rerank.pyindex 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 loggingfrom typing import List, Optionalimport 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 APImodel_name: Model name to use for reranking"""+ super().__init__()self.api_key = api_keyself.api_base = api_baseself.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.pysimilarity index 87%rename from openviking_cli/utils/rerank.pyrename to openviking/models/rerank/volcengine_rerank.pyindex 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 loggingfrom typing import List, Optionalimport requests@@ -14,12 +17,12 @@ from volcengine.auth.SignerV4 import SignerV4from volcengine.base.Request import Requestfrom 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 namemodel_version: Rerank model version"""+ super().__init__()self.ak = akself.sk = skself.host = hostself.model_name = model_nameself.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 sequentiallydata = 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 CohereRerankClientreturn CohereRerankClient.from_config(config)if provider == "litellm":- from openviking_cli.utils.rerank_litellm import LiteLLMRerankClient+ from openviking.models.rerank.litellm_rerank import LiteLLMRerankClientreturn LiteLLMRerankClient.from_config(config)if provider == "openai":- from openviking_cli.utils.rerank_openai import OpenAIRerankClient+ from openviking.models.rerank.openai_rerank import OpenAIRerankClientreturn OpenAIRerankClient.from_config(config)diff --git a/openviking/models/vlm/token_usage.py b/openviking/models/vlm/token_usage.pyindex 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 = 0completion_tokens: int = 0total_tokens: int = 0+ call_count: int = 0last_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_tokensself.completion_tokens += completion_tokensself.total_tokens = self.prompt_tokens + self.completion_tokens+ self.call_count += 1self.last_updated = datetime.now()def reset(self) -> None:@@ -35,6 +37,7 @@ class TokenUsage:self.prompt_tokens = 0self.completion_tokens = 0self.total_tokens = 0+ self.call_count = 0self.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__.pydeleted file mode 100644index 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.0diff --git a/openviking/retrieve/hierarchical_retriever.py b/openviking/retrieve/hierarchical_retriever.pyindex 1fbe4d468..3192ccff8 100644--- a/openviking/retrieve/hierarchical_retriever.py+++ b/openviking/retrieve/hierarchical_retriever.py@@ -15,6 +15,7 @@ from datetime import datetimefrom typing import Any, Dict, List, Optional, Tuplefrom openviking.models.embedder.base import EmbedResult+from openviking.models.rerank import RerankClientfrom openviking.retrieve.memory_lifecycle import hotness_scorefrom openviking.retrieve.retrieval_stats import get_stats_collectorfrom openviking.server.identity import RequestContext, Role@@ -31,7 +32,6 @@ from openviking_cli.retrieve.types import ()from openviking_cli.utils.config import RerankConfigfrom openviking_cli.utils.logger import get_logger-from openviking_cli.utils.rerank import RerankClientlogger = get_logger(__name__)@@ -272,7 +272,7 @@ class HierarchicalRetriever:return fallback_scoresnormalized_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"] = scorereturn 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 scorediff --git a/openviking/server/routers/observer.py b/openviking/server/routers/observer.pyindex 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))[email protected]("/vlm")-async def observer_vlm([email protected]("/models")+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.modelsreturn Response(status="ok", result=_component_to_dict(component))diff --git a/openviking/service/debug_service.py b/openviking/service/debug_service.pyindex cc84c8f0f..955f97d61 100644--- a/openviking/service/debug_service.py+++ b/openviking/service/debug_service.py@@ -11,10 +11,10 @@ from openviking.server.identity import RequestContextfrom openviking.storage import VikingDBManagerfrom openviking.storage.observers import (LockObserver,+ ModelsObserver,QueueObserver,RetrievalObserver,VikingDBObserver,- VLMObserver,)from openviking.storage.queuefs import get_queue_managerfrom 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__.pyindex cc657ddd9..c8b643c6b 100644--- a/openviking/storage/observers/__init__.py+++ b/openviking/storage/observers/__init__.py@@ -2,6 +2,7 @@# SPDX-License-Identifier: AGPL-3.0from .base_observer import BaseObserverfrom .lock_observer import LockObserver+from .models_observer import ModelsObserverfrom .prometheus_observer import (PrometheusObserver,get_prometheus_observer,@@ -10,16 +11,15 @@ from .prometheus_observer import (from .queue_observer import QueueObserverfrom .retrieval_observer import RetrievalObserverfrom .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.pynew file mode 100644index 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 Falsediff --git a/openviking/storage/observers/vlm_observer.py b/openviking/storage/observers/vlm_observer.pydeleted file mode 100644index 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 Falsediff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.pyindex 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())@propertydef 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.tomlindex 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.pyindex 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 attributemock_vlm_instance = MagicMock()mock_config.vlm.get_vlm_instance.return_value = mock_vlm_instancemock_observer = MagicMock()mock_observer.is_healthy.return_value = Truemock_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_observerservice = ObserverService(config=mock_config)- status = service.vlm+ status = service.modelsassert isinstance(status, ComponentStatus)- assert status.name == "vlm"+ assert status.name == "models"assert status.is_healthy is Trueassert 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 = Truemock_observer.has_errors.return_value = Falsemock_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 Truenon_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) == 2assert "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 = Truemock_observer.has_errors.return_value = Falsemock_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 Trueassert 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.modelsassert isinstance(status, ComponentStatus)- assert status.name == "vlm"+ assert status.name == "models"assert status.is_healthy is Falseassert status.has_errors is Trueassert 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 = Truemock_observer.has_errors.return_value = Falsemock_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 Falsediff --git a/tests/misc/test_rerank_openai.py b/tests/misc/test_rerank_openai.pyindex 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, patchimport pytestfrom pydantic import ValidationError+from openviking.models.rerank import OpenAIRerankClient, RerankClientfrom openviking_cli.utils.config.rerank_config import RerankConfig-from openviking_cli.utils.rerank import RerankClient-from openviking_cli.utils.rerank_openai import OpenAIRerankClientclass 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.pyindex 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 CohereRerankClientclass 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 1assert 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 RerankClientfrom openviking_cli.utils.config.rerank_config import RerankConfig- from openviking_cli.utils.rerank import RerankClientconfig = 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 RerankClientfrom openviking_cli.utils.config.rerank_config import RerankConfig- from openviking_cli.utils.rerank import RerankClientconfig = 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 RerankClientfrom openviking_cli.utils.config.rerank_config import RerankConfig- from openviking_cli.utils.rerank import RerankClientconfig = 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 RerankClientfrom openviking_cli.utils.config.rerank_config import RerankConfig- from openviking_cli.utils.rerank import RerankClientconfig = RerankConfig(api_key="key", model_name="rerank-v4.0")client = RerankClient.from_config(config)