Please address the comments from this code review:

## Overall Comments
- In `get_ep` / `_ensure_vec_db`, when `embedding_provider_id` is missing you now only log an error but still call `get_provider_by_id` with a falsy ID and continue; consider either returning a placeholder immediately or keeping the early `raise` to avoid unexpected behavior downstream.
- The temporary provider classes (`TempEmbeddingProvider`, `TempRerankProvider`) are defined inside the methods and re-created on each call; consider moving them to module scope (or a shared helper) to avoid duplication and make their behavior easier to maintain.
- In `TempRerankProvider.rerank` the error message mentions `Embedding Provider` instead of `Rerank Provider`, which is likely a copy-paste mistake and may confuse debugging when the placeholder is triggered.

## Individual Comments

### Comment 1
<location path="astrbot/core/knowledge_base/kb_helper.py" line_range="137-138" />
<code_context>

     async def get_ep(self) -> EmbeddingProvider:
         if not self.kb.embedding_provider_id:
-            raise ValueError(f"知识库 {self.kb.kb_name} 未配置 Embedding Provider")
+            logger.error(f"知识库 {self.kb.kb_name} 未配置 Embedding Provider")
         ep: EmbeddingProvider = await self.prov_mgr.get_provider_by_id(
             self.kb.embedding_provider_id,
</code_context>
<issue_to_address>
**issue (bug_risk):** After logging missing embedding_provider_id, the code still proceeds and may pass an invalid ID into get_provider_by_id.

Previously this branch raised and prevented use of an unset `embedding_provider_id`. Now it logs and then calls `get_provider_by_id(self.kb.embedding_provider_id)`, which will be `None` here, risking undefined or inconsistent behavior depending on `get_provider_by_id`’s implementation. Please either short‑circuit when the ID is missing (e.g., return a placeholder provider) or restore an early failure (raise or return a clearly invalid provider) so downstream code never relies on a `None`/invalid ID.
</issue_to_address>

### Comment 2
<location path="astrbot/core/knowledge_base/kb_helper.py" line_range="186-194" />
<code_context>
+                    super().__init__(provider_config, provider_settings)
+                    self.rerank_provider_id = rerank_provider_id
+
+                async def rerank(
+                    self,
+                    query: str,
+                    documents: list[str],
+                    top_n: int | None = None,
+                ):
+                    raise ValueError(
+                        f"无法找到 ID 为 {self.rerank_provider_id} 的 Embedding Provider"
+                    )
+
</code_context>
<issue_to_address>
**issue (typo):** TempRerankProvider error message refers to an Embedding Provider instead of a Rerank Provider.

The `TempRerankProvider.rerank` error message currently says `Embedding Provider` instead of `Rerank Provider`, which can be confusing when both provider types exist. Please update the message (and its localized text) to reference the rerank provider to match the actual failing dependency.

```suggestion
            class TempRerankProvider(RerankProvider):
                def __init__(
                    self,
                    provider_config: dict,
                    provider_settings: dict,
                    rerank_provider_id: str,
                ) -> None:
                    super().__init__(provider_config, provider_settings)
                    self.rerank_provider_id = rerank_provider_id

                async def rerank(
                    self,
                    query: str,
                    documents: list[str],
                    top_n: int | None = None,
                ):
                    raise ValueError(
                        f"无法找到 ID 为 {self.rerank_provider_id} 的 Rerank Provider"
                    )
```
</issue_to_address>

### Comment 3
<location path="astrbot/core/knowledge_base/kb_helper.py" line_range="167-168" />
<code_context>
+                        f"无法找到 ID 为 {self.embedding_provider_id} 的 Embedding Provider"
+                    )
+
+                def get_dim(self) -> int:
+                    return 512
+
+            ep: EmbeddingProvider = TempEmbeddingProvider(
</code_context>
<issue_to_address>
**issue (bug_risk):** Hardcoded embedding dimension 512 in TempEmbeddingProvider may not match the actual FAISS index or configuration.

`TempEmbeddingProvider.get_dim` always returns 512. If the existing FAISS index or config uses a different dimension, this will lead to runtime errors or index inconsistencies when `_ensure_vec_db` accesses the vector DB. Consider deriving the dimension from the knowledge base config (when available) or raising an explicit error instead of returning a hardcoded value.
</issue_to_address>

### Comment 4
<location path="astrbot/core/knowledge_base/kb_helper.py" line_range="136" />
<code_context>

     async def get_ep(self) -> EmbeddingProvider:
         if not self.kb.embedding_provider_id:
-            raise ValueError(f"知识库 {self.kb.kb_name} 未配置 Embedding Provider")
</code_context>
<issue_to_address>
**issue (complexity):** Consider extracting the placeholder provider classes and error-handling into shared, top-level helpers so the provider methods stay short, consistent, and easier to maintain.

You can keep the new “placeholder provider + logging” behavior while reducing complexity and duplication by:

* Moving the temp providers out of the methods.
* Sharing construction logic.
* Fixing the error message typo.
* Keeping `_ensure_vec_db` simple.

For example:

```python
# module-level helpers

class TempEmbeddingProvider(EmbeddingProvider):
    def __init__(self, provider_id: str) -> None:
        super().__init__({}, {})
        self._provider_id = provider_id

    async def get_embedding(self, text: str) -> list[float]:
        raise ValueError(f"无法找到 ID 为 {self._provider_id} 的 Embedding Provider")

    async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
        raise ValueError(f"无法找到 ID 为 {self._provider_id} 的 Embedding Provider")

    def get_dim(self) -> int:
        return 512


class TempRerankProvider(RerankProvider):
    def __init__(self, provider_id: str) -> None:
        super().__init__({}, {})
        self._provider_id = provider_id

    async def rerank(
        self,
        query: str,
        documents: list[str],
        top_n: int | None = None,
    ):
        raise ValueError(f"无法找到 ID 为 {self._provider_id} 的 Rerank Provider")
```

Then the methods become straightforward, with no inner classes and consistent behavior:

```python
async def get_ep(self) -> EmbeddingProvider:
    if not self.kb.embedding_provider_id:
        logger.error(f"知识库 {self.kb.kb_name} 未配置 Embedding Provider")
        return TempEmbeddingProvider("<missing>")

    ep: EmbeddingProvider | None = await self.prov_mgr.get_provider_by_id(
        self.kb.embedding_provider_id,  # type: ignore[arg-type]
    )
    if not ep:
        logger.error(
            f"无法找到 ID 为 {self.kb.embedding_provider_id} 的 Embedding Provider, 使用占位 Embedding Provider"
        )
        return TempEmbeddingProvider(self.kb.embedding_provider_id)

    return ep
```

```python
async def get_rp(self) -> RerankProvider | None:
    if not self.kb.rerank_provider_id:
        return None

    rp: RerankProvider | None = await self.prov_mgr.get_provider_by_id(
        self.kb.rerank_provider_id,  # type: ignore[arg-type]
    )
    if not rp:
        logger.error(
            f"无法找到 ID 为 {self.kb.rerank_provider_id} 的 Rerank Provider, 使用占位 Rerank Provider"
        )
        return TempRerankProvider(self.kb.rerank_provider_id)

    return rp
```

`_ensure_vec_db` can stay focused on constructing the vector DB, delegating all error semantics to `get_ep` / `get_rp`:

```python
async def _ensure_vec_db(self) -> FaissVecDB:
    if not self.kb.embedding_provider_id:
        logger.error(f"知识库 {self.kb.kb_name} 未配置 Embedding Provider")

    ep = await self.get_ep()
    rp = await self.get_rp()

    vec_db = FaissVecDB(
        doc_store_path=str(self.kb_dir / "doc.db"),
        index_store_path=str(self.kb_dir / "index.faiss"),
        embedding_provider=ep,
        rerank_provider=rp,
    )
    ...
```

This keeps the new behavior (logging + placeholder providers + delayed error), but:

* Removes inner classes from methods.
* Centralizes and deduplicates the temp-provider logic.
* Fixes the “Embedding Provider”/“Rerank Provider” message inconsistency.
* Makes `get_ep` / `get_rp` easier to read and maintain.
</issue_to_address>