vent_ai_platform/app/schemas/knowledge.py

from __future__ import annotations

from datetime import datetime
from typing import Any

from pydantic import BaseModel, Field

from app.schemas.common import ORMModel


class KnowledgeItemCreate(BaseModel):
    mine_id: str | None = None
    document_id: str | None = None
    code: str | None = None
    title: str
    knowledge_type: str
    category: str = ""
    source_type: str = "manual"
    source_ref: str = ""
    content: str
    summary: str = ""
    tags: list[str] = Field(default_factory=list)
    status: str = "published"
    version: str = "V1.0"
    confidence: float | None = None
    metadata: dict = Field(default_factory=dict)


class KnowledgeItemRead(ORMModel):
    id: str
    mine_id: str | None
    document_id: str | None
    code: str | None
    title: str
    knowledge_type: str
    category: str
    source_type: str
    source_ref: str
    content: str
    summary: str
    tags: list
    status: str
    version: str
    confidence: float | None
    is_verified: bool
    verified_by: str
    metadata: dict = Field(validation_alias="metadata_json")
    created_at: datetime
    updated_at: datetime


class KnowledgeSearchRequest(BaseModel):
    query: str
    mine_id: str | None = None
    knowledge_type: str | None = None
    category: str | None = None
    limit: int = Field(default=10, ge=1, le=50)


class KnowledgeSearchHit(BaseModel):
    item: KnowledgeItemRead
    score: float = 0
    highlight: str = ""


class KnowledgeSearchResponse(BaseModel):
    query: str
    total: int
    items: list[KnowledgeSearchHit]


class KnowledgeServiceStatus(BaseModel):
    available: bool = False
    base_url: str = ""
    version: str = ""
    mode: str = ""
    status: str = ""
    total_notes: int = 0
    total_chunks: int = 0
    embedding_model: str = ""
    semantic_enabled: bool = False
    last_indexed: str | None = None
    error: str = ""


class KnowledgeCategoryStat(BaseModel):
    key: str
    name: str
    count: int = 0
    description: str = ""
    available: bool = True


class KnowledgeOverviewResponse(BaseModel):
    service: KnowledgeServiceStatus
    total_notes: int = 0
    total_chunks: int = 0
    category_counts: list[KnowledgeCategoryStat] = Field(default_factory=list)
    search_mode: str = "keyword"
    min_score: float = 0
    min_match_ratio: float = 0
    last_indexed: str | None = None
    average_response_ms: float | None = None


class KnowledgeCatalogItem(BaseModel):
    note_id: str
    title: str
    category: str = "other"
    category_name: str = "其他"
    tags: list[str] = Field(default_factory=list)
    aliases: list[str] = Field(default_factory=list)
    file_path: str = ""
    updated: str = ""
    chunk_count: int = 0
    confidence: str = ""
    status: str = ""
    version: str = ""


class KnowledgeCatalogResponse(BaseModel):
    items: list[KnowledgeCatalogItem]
    total: int
    page: int
    page_size: int
    service: KnowledgeServiceStatus


class KnowledgeNoteChunk(BaseModel):
    chunk_id: str = ""
    heading: str = ""
    content: str = ""


class KnowledgeNoteDetail(KnowledgeCatalogItem):
    full_content: str = ""
    links: list[Any] = Field(default_factory=list)
    chunks: list[KnowledgeNoteChunk] = Field(default_factory=list)


class KnowledgeAskRequest(BaseModel):
    question: str = Field(min_length=1)
    top_k: int = Field(default=5, ge=1, le=20)
    search_mode: str | None = None
    category: str | None = None
    tag: str | None = None
    generate_answer: bool = True


class KnowledgeSource(BaseModel):
    citation_index: int = 0
    note_id: str = ""
    title: str
    file_path: str = ""
    score: float = 0
    heading: str = ""
    snippet: str = ""
    category: str = "other"
    category_name: str = "其他"


class KnowledgeAskResponse(BaseModel):
    question: str
    answer: str
    answer_status: str
    answer_model: str = ""
    generation_enabled: bool = True
    steps: list[str] = Field(default_factory=list)
    sources: list[KnowledgeSource] = Field(default_factory=list)
    requested_mode: str = "keyword"
    search_mode: str = "keyword"
    retrieval_ms: float = 0
    generation_ms: float = 0
    context_chars: int = 0
    latency_ms: float = 0
    total_candidates: int = 0
    degraded: bool = False


class KnowledgeGraphNode(BaseModel):
    id: str
    label: str
    sub_label: str = ""
    node_type: str
    value: int = 0
    sample_notes: list[str] = Field(default_factory=list)
    x: float
    y: float


class KnowledgeGraphEdge(BaseModel):
    source: str
    target: str
    relation: str = ""
    weight: int = 1


class KnowledgeGraphResponse(BaseModel):
    topic: str
    nodes: list[KnowledgeGraphNode] = Field(default_factory=list)
    edges: list[KnowledgeGraphEdge] = Field(default_factory=list)