diff --git a/astrbot/dashboard/api/knowledge_bases.py b/astrbot/dashboard/api/knowledge_bases.py
index 595f6ff911..ed0498098c 100644
--- a/astrbot/dashboard/api/knowledge_bases.py
+++ b/astrbot/dashboard/api/knowledge_bases.py
@@ -9,6 +9,7 @@
 from astrbot.dashboard.async_utils import run_maybe_async
 from astrbot.dashboard.responses import error, ok
 from astrbot.dashboard.schemas import (
+    KnowledgeBaseCreateRequest,
     KnowledgeBaseImportRequest,
     KnowledgeBaseRequest,
     KnowledgeBaseRetrieveRequest,
@@ -53,14 +54,6 @@ def _to_int(value: Any, default: int) -> int:
         return default
 
 
-def _model_dict(payload) -> dict[str, Any]:
-    if payload is None:
-        return {}
-    if hasattr(payload, "model_dump"):
-        return payload.model_dump(exclude_none=True)
-    return payload if isinstance(payload, dict) else {}
-
-
 async def _run(operation, *, prefix: str):
     try:
         result = await run_maybe_async(operation)
@@ -102,12 +95,12 @@ async def list_knowledge_bases(
 
 @router.post("/knowledge-bases")
 async def create_knowledge_base(
-    payload: KnowledgeBaseRequest,
+    payload: KnowledgeBaseCreateRequest,
     _auth: AuthContext = Depends(require_kb_scope),
     service: KnowledgeBaseService = Depends(get_service),
 ):
     return await _run(
-        lambda: service.create_kb(_model_dict(payload)),
+        lambda: service.create_kb(payload.canonical_payload()),
         prefix="创建知识库失败",
     )
 
@@ -140,9 +133,8 @@ async def update_knowledge_base(
     _auth: AuthContext = Depends(require_kb_scope),
     service: KnowledgeBaseService = Depends(get_service),
 ):
-    body = _model_dict(payload)
     return await _run(
-        lambda: service.update_kb({"kb_id": kb_id, **body}),
+        lambda: service.update_kb({**payload.canonical_payload(), "kb_id": kb_id}),
         prefix="更新知识库失败",
     )
 
@@ -213,7 +205,7 @@ async def import_knowledge_base_documents(
     _auth: AuthContext = Depends(require_kb_scope),
     service: KnowledgeBaseService = Depends(get_service),
 ):
-    body = _model_dict(payload)
+    body = payload.model_dump(exclude_none=True)
     return await _run(
         lambda: service.import_documents({"kb_id": kb_id, **body}),
         prefix="导入文档失败",
@@ -227,7 +219,7 @@ async def import_knowledge_base_document_url(
     _auth: AuthContext = Depends(require_kb_scope),
     service: KnowledgeBaseService = Depends(get_service),
 ):
-    body = _model_dict(payload)
+    body = payload.model_dump(exclude_none=True)
     return await _run(
         lambda: service.upload_document_from_url({"kb_id": kb_id, **body}),
         prefix="从URL上传文档失败",
@@ -307,7 +299,7 @@ async def retrieve_knowledge_base(
     _auth: AuthContext = Depends(require_kb_scope),
     service: KnowledgeBaseService = Depends(get_service),
 ):
-    body = _model_dict(payload)
+    body = payload.model_dump(exclude_none=True)
     return await _run(
         lambda: service.retrieve({"kb_id": kb_id, **body}),
         prefix="检索失败",
diff --git a/astrbot/dashboard/schemas.py b/astrbot/dashboard/schemas.py
index f37449c532..c7b5d00ba8 100644
--- a/astrbot/dashboard/schemas.py
+++ b/astrbot/dashboard/schemas.py
@@ -205,13 +205,46 @@ class ImMessageRequest(OpenModel):
 
 
 class KnowledgeBaseRequest(OpenModel):
-    kb_id: str | None = None
-    name: str | None = None
+    kb_name: str | None = Field(None, alias="name")
     description: str | None = None
+    emoji: str | None = None
     embedding_provider_id: str | None = None
     rerank_provider_id: str | None = None
     chunk_size: int | None = None
     chunk_overlap: int | None = None
+    top_k_dense: int | None = None
+    top_k_sparse: int | None = None
+    top_m_final: int | None = None
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    def canonical_payload(self) -> dict[str, Any]:
+        """Return the service-facing knowledge base payload.
+
+        Returns:
+            Dictionary accepted by KnowledgeBaseService.
+        """
+        return self.model_dump(
+            exclude_unset=True,
+            include={
+                "kb_name",
+                "description",
+                "emoji",
+                "embedding_provider_id",
+                "rerank_provider_id",
+                "chunk_size",
+                "chunk_overlap",
+                "top_k_dense",
+                "top_k_sparse",
+                "top_m_final",
+            },
+            by_alias=False,
+        )
+
+
+class KnowledgeBaseCreateRequest(KnowledgeBaseRequest):
+    kb_name: str = Field(..., alias="name")
+    embedding_provider_id: str
 
 
 class KnowledgeBaseImportRequest(OpenModel):
diff --git a/astrbot/dashboard/services/knowledge_base_service.py b/astrbot/dashboard/services/knowledge_base_service.py
index ec162aa299..76ad91359d 100644
--- a/astrbot/dashboard/services/knowledge_base_service.py
+++ b/astrbot/dashboard/services/knowledge_base_service.py
@@ -12,6 +12,7 @@
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
 from astrbot.core.provider.provider import EmbeddingProvider, RerankProvider
 from astrbot.core.utils.astrbot_path import get_astrbot_temp_path
+from astrbot.dashboard.schemas import KnowledgeBaseRequest
 from astrbot.dashboard.utils import generate_tsne_visualization
 
 
@@ -29,6 +30,19 @@ def __init__(self, core_lifecycle: AstrBotCoreLifecycle) -> None:
     def _payload(data: object) -> dict[str, Any]:
         return data if isinstance(data, dict) else {}
 
+    @staticmethod
+    def _canonical_kb_payload(data: object) -> dict[str, Any]:
+        """Normalize knowledge base create/update payloads.
+
+        Uses KnowledgeBaseRequest to handle the legacy ``name`` →
+        ``kb_name`` migration while preserving operational fields
+        like ``kb_id``.
+        """
+        raw = KnowledgeBaseService._payload(data)
+        canonical = KnowledgeBaseRequest(**raw).canonical_payload()
+        raw.update(canonical)
+        return raw
+
     def get_kb_manager(self):
         return self.core_lifecycle.kb_manager
 
@@ -293,7 +307,7 @@ async def list_kbs_from_dashboard_query(self, *, page, page_size) -> dict[str, A
 
     async def create_kb(self, data: object) -> tuple[dict[str, Any], str]:
         kb_manager = self.get_kb_manager()
-        payload = self._payload(data)
+        payload = self._canonical_kb_payload(data)
         kb_name = payload.get("kb_name")
         if not kb_name:
             raise KnowledgeBaseServiceError("知识库名称不能为空")
@@ -363,7 +377,7 @@ async def get_kb_from_dashboard_query(self, kb_id: str | None) -> dict[str, Any]
         return await self.get_kb(kb_id)
 
     async def update_kb(self, data: object) -> tuple[dict[str, Any], str]:
-        payload = self._payload(data)
+        payload = self._canonical_kb_payload(data)
         kb_id = payload.get("kb_id")
         if not kb_id:
             raise KnowledgeBaseServiceError("缺少参数 kb_id")
@@ -380,28 +394,20 @@ async def update_kb(self, data: object) -> tuple[dict[str, Any], str]:
             "top_k_sparse",
             "top_m_final",
         ]
-        if all(payload.get(key) is None for key in update_keys):
+        provided_updates = {key: payload[key] for key in update_keys if key in payload}
+        if not provided_updates:
             raise KnowledgeBaseServiceError("至少需要提供一个更新字段")
 
         current_kb = await self.get_kb_manager().get_kb(kb_id)
-        kb_name = payload.get("kb_name")
-        if kb_name is None:
-            if not current_kb:
-                raise KnowledgeBaseServiceError("知识库不存在")
-            kb_name = current_kb.kb.kb_name
+        if not current_kb:
+            raise KnowledgeBaseServiceError("知识库不存在")
+        current = current_kb.kb
+        update_data = {key: getattr(current, key, None) for key in update_keys}
+        update_data.update(provided_updates)
 
         kb_helper = await self.get_kb_manager().update_kb(
             kb_id=kb_id,
-            kb_name=kb_name,
-            description=payload.get("description"),
-            emoji=payload.get("emoji"),
-            embedding_provider_id=payload.get("embedding_provider_id"),
-            rerank_provider_id=payload.get("rerank_provider_id"),
-            chunk_size=payload.get("chunk_size"),
-            chunk_overlap=payload.get("chunk_overlap"),
-            top_k_dense=payload.get("top_k_dense"),
-            top_k_sparse=payload.get("top_k_sparse"),
-            top_m_final=payload.get("top_m_final"),
+            **update_data,
         )
         if not kb_helper:
             raise KnowledgeBaseServiceError("知识库不存在")
@@ -762,11 +768,11 @@ async def retrieve(self, data: object) -> dict[str, Any]:
 
         if not query:
             raise KnowledgeBaseServiceError("缺少参数 query")
+        kb_manager = self.get_kb_manager()
         if not kb_names or not isinstance(kb_names, list):
             raise KnowledgeBaseServiceError("缺少参数 kb_names 或格式错误")
 
         top_k = payload.get("top_k", 5)
-        kb_manager = self.get_kb_manager()
         results = await kb_manager.retrieve(
             query=query,
             kb_names=kb_names,
diff --git a/dashboard/src/api/generated/openapi-v1/types.gen.ts b/dashboard/src/api/generated/openapi-v1/types.gen.ts
index 49e94b2bb1..ffe7c5e394 100644
--- a/dashboard/src/api/generated/openapi-v1/types.gen.ts
+++ b/dashboard/src/api/generated/openapi-v1/types.gen.ts
@@ -255,13 +255,22 @@ export type JsonSchema = {
     [key: string]: unknown;
 };
 
+export type KnowledgeBaseCreateRequest = KnowledgeBaseRequest & {
+    kb_name: string;
+    embedding_provider_id: string;
+};
+
 export type KnowledgeBaseRequest = {
-    name: string;
+    kb_name?: string;
     description?: string;
-    embedding_provider_id?: string;
-    rerank_provider_id?: string;
-    chunking?: DynamicConfig;
-    metadata?: DynamicConfig;
+    emoji?: string;
+    embedding_provider_id?: (string) | null;
+    rerank_provider_id?: (string) | null;
+    chunk_size?: number;
+    chunk_overlap?: number;
+    top_k_dense?: number;
+    top_k_sparse?: number;
+    top_m_final?: number;
 };
 
 export type KnowledgeDocumentImportRequest = {
@@ -271,7 +280,6 @@ export type KnowledgeDocumentImportRequest = {
 
 export type KnowledgeDocumentUploadRequest = {
     file: (Blob | File);
-    parser?: string;
 };
 
 export type KnowledgeDocumentUrlImportRequest = {
@@ -2606,7 +2614,7 @@ export type ListKnowledgeBasesResponse = (SuccessEnvelope);
 export type ListKnowledgeBasesError = unknown;
 
 export type CreateKnowledgeBaseData = {
-    body: KnowledgeBaseRequest;
+    body: KnowledgeBaseCreateRequest;
 };
 
 export type CreateKnowledgeBaseResponse = (SuccessEnvelope);
diff --git a/dashboard/src/api/v1.ts b/dashboard/src/api/v1.ts
index 29c365caa5..d10f532c22 100644
--- a/dashboard/src/api/v1.ts
+++ b/dashboard/src/api/v1.ts
@@ -32,6 +32,8 @@ import {
   type DynamicConfig,
   type EnabledPatch,
   type GhproxyTestRequest,
+  type KnowledgeBaseCreateRequest,
+  type KnowledgeBaseRequest,
   type LoginRequest,
   type ListConversationsData,
   type McpServerConfig,
@@ -1366,16 +1368,16 @@ export const knowledgeApi = {
       openApiV1.getKnowledgeBase({ path: { kb_id: kbId } }),
     );
   },
-  create(config: OpenConfig) {
+  create(config: KnowledgeBaseCreateRequest) {
     return typed<OpenConfig>(
-      openApiV1.createKnowledgeBase({ body: config as any }),
+      openApiV1.createKnowledgeBase({ body: config }),
     );
   },
-  update(kbId: string, config: OpenConfig) {
+  update(kbId: string, config: KnowledgeBaseRequest) {
     return typed<OpenConfig>(
       openApiV1.updateKnowledgeBase({
         path: { kb_id: kbId },
-        body: config as any,
+        body: config,
       }),
     );
   },
diff --git a/dashboard/src/views/knowledge-base/KBList.vue b/dashboard/src/views/knowledge-base/KBList.vue
index 4ca8b593d9..d9fd6772d9 100644
--- a/dashboard/src/views/knowledge-base/KBList.vue
+++ b/dashboard/src/views/knowledge-base/KBList.vue
@@ -161,7 +161,9 @@
 
             <v-select v-model="formData.embedding_provider_id" :items="embeddingProviders"
               :item-title="item => item.embedding_model || item.id" :item-value="'id'"
-              :label="t('create.embeddingModelLabel')" variant="outlined" class="mb-4" :disabled="editingKB !== null" hint="嵌入模型选择后无法修改，如需更换请创建新的知识库。" persistent-hint>
+              :label="t('create.embeddingModelLabel')" variant="outlined" class="mb-4" :disabled="editingKB !== null"
+              :rules="[v => editingKB !== null || !!v || t('create.embeddingModelRequired')]" required
+              hint="嵌入模型选择后无法修改，如需更换请创建新的知识库。" persistent-hint>
               <template #item="{ props, item }">
                 <v-list-item v-bind="props">
                   <template #subtitle>
@@ -455,7 +457,10 @@ const submitForm = async () => {
     if (editingKB.value) {
       response = await knowledgeApi.update(editingKB.value.kb_id, payload)
     } else {
-      response = await knowledgeApi.create(payload)
+      response = await knowledgeApi.create({
+        ...payload,
+        embedding_provider_id: formData.value.embedding_provider_id!
+      })
     }
 
     if (response.data.status === 'ok') {
diff --git a/openspec/openapi-v1.yaml b/openspec/openapi-v1.yaml
index e8d1edb97d..57db93fcd0 100644
--- a/openspec/openapi-v1.yaml
+++ b/openspec/openapi-v1.yaml
@@ -3381,7 +3381,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: "#/components/schemas/KnowledgeBaseRequest"
+              $ref: "#/components/schemas/KnowledgeBaseCreateRequest"
       responses:
         "200":
           $ref: "#/components/responses/Ok"
@@ -5700,22 +5700,40 @@ components:
 
     KnowledgeBaseRequest:
       type: object
-      required: [name]
       properties:
-        name:
+        kb_name:
           type: string
         description:
           type: string
-        embedding_provider_id:
+        emoji:
           type: string
+        embedding_provider_id:
+          type: [string, "null"]
         rerank_provider_id:
-          type: string
-        chunking:
-          $ref: "#/components/schemas/DynamicConfig"
-        metadata:
-          $ref: "#/components/schemas/DynamicConfig"
+          type: [string, "null"]
+        chunk_size:
+          type: integer
+        chunk_overlap:
+          type: integer
+        top_k_dense:
+          type: integer
+        top_k_sparse:
+          type: integer
+        top_m_final:
+          type: integer
       additionalProperties: false
 
+    KnowledgeBaseCreateRequest:
+      allOf:
+        - $ref: "#/components/schemas/KnowledgeBaseRequest"
+        - type: object
+          required: [kb_name, embedding_provider_id]
+          properties:
+            kb_name:
+              type: string
+            embedding_provider_id:
+              type: string
+
     KnowledgeDocumentUploadRequest:
       type: object
       required: [file]
@@ -5723,8 +5741,6 @@ components:
         file:
           type: string
           format: binary
-        parser:
-          type: string
 
     KnowledgeDocumentImportRequest:
       type: object
diff --git a/tests/unit/test_knowledge_base_service_contract.py b/tests/unit/test_knowledge_base_service_contract.py
new file mode 100644
index 0000000000..5bcdddf2fd
--- /dev/null
+++ b/tests/unit/test_knowledge_base_service_contract.py
@@ -0,0 +1,266 @@
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from fastapi import Request
+
+from astrbot.core.provider.provider import EmbeddingProvider
+from astrbot.dashboard.api.knowledge_bases import (
+    list_knowledge_bases,
+)
+from astrbot.dashboard.schemas import (
+    KnowledgeBaseRequest,
+)
+from astrbot.dashboard.services.knowledge_base_service import (
+    KnowledgeBaseService,
+    KnowledgeBaseServiceError,
+)
+
+
+class FakeEmbeddingProvider(EmbeddingProvider):
+    def __init__(self):
+        super().__init__({}, {})
+
+    async def get_embedding(self, text: str) -> list[float]:
+        return [0.1, 0.2]
+
+    async def get_embeddings(self, text: list[str]) -> list[list[float]]:
+        return [[0.1, 0.2] for _ in text]
+
+    def get_dim(self) -> int:
+        return 2
+
+
+def make_service(kb_manager) -> KnowledgeBaseService:
+    service = KnowledgeBaseService.__new__(KnowledgeBaseService)
+    service.core_lifecycle = SimpleNamespace(kb_manager=kb_manager)
+    service.upload_progress = {}
+    service.upload_tasks = {}
+    return service
+
+
+def make_kb(kb_id: str, kb_name: str):
+    return SimpleNamespace(
+        kb_id=kb_id,
+        kb_name=kb_name,
+        description="description",
+        emoji="book",
+        embedding_provider_id="embedding-1",
+        rerank_provider_id="rerank-1",
+        chunk_size=512,
+        chunk_overlap=50,
+        top_k_dense=50,
+        top_k_sparse=50,
+        top_m_final=5,
+        model_dump=lambda: {"kb_id": kb_id, "kb_name": kb_name},
+    )
+
+
+def make_request(query_string: bytes) -> Request:
+    return Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/api/v1/knowledge-bases",
+            "query_string": query_string,
+            "headers": [],
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_list_kbs_applies_pagination():
+    kb_manager = MagicMock()
+    kb_manager.list_kbs = AsyncMock(
+        return_value=[
+            make_kb("kb-1", "one"),
+            make_kb("kb-2", "two"),
+            make_kb("kb-3", "three"),
+        ]
+    )
+    kb_manager.get_kb = AsyncMock(
+        side_effect=lambda kb_id: SimpleNamespace(init_error=None)
+    )
+    service = make_service(kb_manager)
+
+    result = await service.list_kbs(page=2, page_size=2)
+
+    assert result == {
+        "items": [{"kb_id": "kb-3", "kb_name": "three"}],
+        "page": 2,
+        "page_size": 2,
+        "total": 3,
+    }
+
+
+@pytest.mark.asyncio
+async def test_list_route_uses_default_page_size_without_query_params():
+    service = MagicMock()
+    service.list_kbs = AsyncMock(return_value={"items": [], "total": 0})
+
+    response = await list_knowledge_bases(
+        make_request(b""),
+        _auth=object(),
+        service=service,
+    )
+
+    assert response["status"] == "ok"
+    service.list_kbs.assert_awaited_once_with(page=1, page_size=20)
+
+
+@pytest.mark.asyncio
+async def test_list_route_uses_default_page_size_when_page_is_explicit():
+    service = MagicMock()
+    service.list_kbs = AsyncMock(return_value={"items": [], "total": 0})
+
+    response = await list_knowledge_bases(
+        make_request(b"page=2"),
+        _auth=object(),
+        service=service,
+    )
+
+    assert response["status"] == "ok"
+    service.list_kbs.assert_awaited_once_with(page=2, page_size=20)
+
+
+@pytest.mark.asyncio
+async def test_create_kb_accepts_legacy_name_field():
+    kb = make_kb("kb-1", "From Name")
+    kb_manager = MagicMock()
+    kb_manager.provider_manager.get_provider_by_id = AsyncMock(
+        return_value=FakeEmbeddingProvider()
+    )
+    kb_manager.create_kb = AsyncMock(return_value=SimpleNamespace(kb=kb))
+    service = make_service(kb_manager)
+
+    result, message = await service.create_kb(
+        {
+            "name": "From Name",
+            "embedding_provider_id": "embedding-1",
+            "top_k_dense": 12,
+            "top_k_sparse": 8,
+            "top_m_final": 3,
+        }
+    )
+
+    assert message == "创建知识库成功"
+    assert result == {"kb_id": "kb-1", "kb_name": "From Name"}
+    kb_manager.create_kb.assert_awaited_once_with(
+        kb_name="From Name",
+        description=None,
+        emoji=None,
+        embedding_provider_id="embedding-1",
+        rerank_provider_id=None,
+        chunk_size=None,
+        chunk_overlap=None,
+        top_k_dense=12,
+        top_k_sparse=8,
+        top_m_final=3,
+    )
+
+
+@pytest.mark.asyncio
+async def test_update_kb_preserves_omitted_fields():
+    kb = make_kb("kb-1", "Docs")
+    kb_manager = MagicMock()
+    kb_manager.get_kb = AsyncMock(return_value=SimpleNamespace(kb=kb))
+    kb_manager.update_kb = AsyncMock(return_value=SimpleNamespace(kb=kb))
+    service = make_service(kb_manager)
+
+    await service.update_kb({"kb_id": "kb-1", "chunk_size": 1024})
+
+    kb_manager.update_kb.assert_awaited_once_with(
+        kb_id="kb-1",
+        kb_name="Docs",
+        description="description",
+        emoji="book",
+        embedding_provider_id="embedding-1",
+        rerank_provider_id="rerank-1",
+        chunk_size=1024,
+        chunk_overlap=50,
+        top_k_dense=50,
+        top_k_sparse=50,
+        top_m_final=5,
+    )
+
+
+@pytest.mark.asyncio
+async def test_update_kb_allows_explicit_rerank_provider_clear():
+    kb = make_kb("kb-1", "Docs")
+    kb_manager = MagicMock()
+    kb_manager.get_kb = AsyncMock(return_value=SimpleNamespace(kb=kb))
+    kb_manager.update_kb = AsyncMock(return_value=SimpleNamespace(kb=kb))
+    service = make_service(kb_manager)
+
+    await service.update_kb({"kb_id": "kb-1", "rerank_provider_id": None})
+
+    kb_manager.update_kb.assert_awaited_once()
+    assert kb_manager.update_kb.await_args.kwargs["rerank_provider_id"] is None
+
+
+def test_knowledge_base_schemas_match_service_contract():
+    create_payload = KnowledgeBaseRequest(
+        kb_name="Docs",
+        name="Legacy",
+        emoji="book",
+        top_k_dense=12,
+        top_k_sparse=8,
+        top_m_final=3,
+        kb_id="body-kb-id",
+    ).canonical_payload()
+    assert create_payload == {
+        "kb_name": "Docs",
+        "emoji": "book",
+        "top_k_dense": 12,
+        "top_k_sparse": 8,
+        "top_m_final": 3,
+    }
+    assert "kb_id" not in create_payload
+
+
+def test_knowledge_base_request_preserves_explicit_null_updates():
+    payload = KnowledgeBaseRequest(rerank_provider_id=None).canonical_payload()
+
+    assert payload == {"rerank_provider_id": None}
+
+
+def test_knowledge_base_request_omits_unset_none_fields():
+    payload = KnowledgeBaseRequest(kb_name="Docs").canonical_payload()
+
+    assert payload == {"kb_name": "Docs"}
+
+
+def test_knowledge_base_request_uses_legacy_name_as_input_alias():
+    payload = KnowledgeBaseRequest(name="Legacy Name").canonical_payload()
+
+    assert payload == {"kb_name": "Legacy Name"}
+
+
+@pytest.mark.asyncio
+async def test_create_kb_raises_when_kb_name_is_missing():
+    kb_manager = MagicMock()
+    service = make_service(kb_manager)
+
+    with pytest.raises(KnowledgeBaseServiceError, match="知识库名称不能为空"):
+        await service.create_kb({"embedding_provider_id": "embedding-1"})
+
+
+@pytest.mark.asyncio
+async def test_create_kb_raises_when_embedding_provider_is_missing():
+    kb_manager = MagicMock()
+    service = make_service(kb_manager)
+
+    with pytest.raises(KnowledgeBaseServiceError, match="缺少参数 embedding_provider_id"):
+        await service.create_kb({"kb_name": "Test KB"})
+
+
+@pytest.mark.asyncio
+async def test_create_kb_raises_when_embedding_provider_is_invalid():
+    kb_manager = MagicMock()
+    kb_manager.provider_manager.get_provider_by_id = AsyncMock(return_value=None)
+    service = make_service(kb_manager)
+
+    with pytest.raises(KnowledgeBaseServiceError, match="嵌入模型不存在或类型错误"):
+        await service.create_kb(
+            {"kb_name": "Test KB", "embedding_provider_id": "missing-provider"}
+        )