mba-ia-cache/models.py at main · devfullcycle/mba-ia-cache · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
from typing import Any, Literal, Optional

from pydantic import BaseModel


class TicketRequest(BaseModel):
    message: str


class TicketAnalysis(BaseModel):
    category: Literal[
        "billing",
        "technical_support",
        "account",
        "cancellation",
        "other",
    ]
    confidence: float
    reason: str


class Fingerprint(BaseModel):
    prompt_version: str
    rules_version: str
    model_capability: str
    normalized_text: str


class CacheInfo(BaseModel):
    hit: bool
    key: str
    fingerprint: Fingerprint


class SemanticCacheInfo(BaseModel):
    attempted: bool
    hit: bool
    decision: str
    reason: str
    threshold: float
    best_match_similarity: Optional[float] = None
    best_match_distance: Optional[float] = None
    best_match_id: Optional[str] = None
    best_match_input_text: Optional[str] = None


class SemanticCacheWriteInfo(BaseModel):
    attempted: bool
    saved: bool
    reason: str
    item_id: Optional[str] = None
    embedding_dimension: Optional[int] = None


class TicketResponse(BaseModel):
    source: str
    ai_call_number: int
    elapsed_ms: int
    cache: CacheInfo
    semantic_cache: SemanticCacheInfo
    semantic_cache_write: SemanticCacheWriteInfo
    result: TicketAnalysis


class ConfigUpdate(BaseModel):
    prompt_version: Optional[str] = None
    rules_version: Optional[str] = None
    model_capability: Optional[str] = None
    semantic_cache_threshold: Optional[float] = None


class ConfigResponse(BaseModel):
    prompt_version: str
    rules_version: str
    model_capability: str
    semantic_cache_threshold: float
    embedding_model: str
    embedding_dimensions: int
    database_configured: bool


class DatabaseStatusResponse(BaseModel):
    connected: bool
    pgvector_enabled: bool
    embedding_dimensions: int
    table: Optional[str] = None
    error: Optional[str] = None


class SemanticCacheCreateRequest(BaseModel):
    input_text: str
    response_json: dict[str, Any]


class SemanticCacheCreateResponse(BaseModel):
    id: str
    prompt_version: str
    rules_version: str
    model_capability: str
    input_text: str
    normalized_text: str
    embedding_model: str
    embedding_dimension: int
    embedding_preview: list[float]
    response_json: dict[str, Any]
    created: bool


class EmbeddingsRequest(BaseModel):
    texts: list[str]


class EmbeddingItem(BaseModel):
    text: str
    normalized_text: str
    embedding_dimension: int
    embedding_preview: list[float]


class EmbeddingsResponse(BaseModel):
    model: str
    items: list[EmbeddingItem]


class SemanticCacheSearchRequest(BaseModel):
    input_text: str
    limit: int = 5


class SemanticCacheSearchQuery(BaseModel):
    input_text: str
    normalized_text: str
    embedding_model: str
    embedding_dimension: int


class SemanticCacheSearchFilters(BaseModel):
    prompt_version: str
    rules_version: str
    model_capability: str


class SemanticCacheSearchItem(BaseModel):
    id: str
    input_text: str
    normalized_text: str
    distance: float
    similarity: float
    response_json: dict[str, Any]
    created_at: str


class SemanticCacheSearchResponse(BaseModel):
    query: SemanticCacheSearchQuery
    filters: SemanticCacheSearchFilters
    count: int
    items: list[SemanticCacheSearchItem]


class SemanticCacheEvaluateRequest(BaseModel):
    input_text: str
    threshold: float = 0.9
    limit: int = 5


class SemanticCacheEvaluation(BaseModel):
    threshold: float
    decision: Literal["accepted", "rejected"]
    reason: str
    best_match_similarity: Optional[float] = None
    best_match_distance: Optional[float] = None


class SemanticCacheEvaluateResponse(BaseModel):
    query: SemanticCacheSearchQuery
    filters: SemanticCacheSearchFilters
    evaluation: SemanticCacheEvaluation
    best_match: Optional[SemanticCacheSearchItem] = None
    candidates: list[SemanticCacheSearchItem]