@omnizap-system/omnizap 2.5.12

package/ml/clip_classifier/main.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from pydantic import BaseModel, Field
+
+from classifier import (
+    ADAPTIVE_ALPHA,
+    AFFINITY_WEIGHT_CAP,
+    CLIP_TOP_K,
+    DEFAULT_LABELS,
+    ENABLE_ADAPTIVE_SCORING,
+    ENABLE_LLM_EXPANSION_GATING,
+    ENABLE_CLUSTERING,
+    ENABLE_EMBEDDING_CACHE,
+    ENABLE_LLM_LABEL_EXPANSION,
+    ENTROPY_NORMALIZED_THRESHOLD,
+    ENTROPY_THRESHOLD,
+    LLM_EXPANSION_MAX_ENTROPY_NORMALIZED,
+    LLM_EXPANSION_MIN_MARGIN,
+    NSFW_THRESHOLD,
+    classify_image_bytes,
+    get_classifier,
+    register_pack_feedback,
+)
+
+app = FastAPI(
+    title="OmniZap MobileCLIP Classifier API",
+    description="Classificação de imagens com MobileCLIP (via OpenCLIP) para categorizar stickers/packs.",
+    version="2.0.0",
+)
+
+
+class TopLabelEntry(BaseModel):
+    label: str
+    score: float
+    logit: float
+    clip_score: float
+
+
+class SimilarImageEntry(BaseModel):
+    image_hash: str
+    asset_id: str | None = None
+    similarity: float
+
+
+class LlmExpansionPayload(BaseModel):
+    subtags: list[str] = Field(default_factory=list)
+    style_traits: list[str] = Field(default_factory=list)
+    emotions: list[str] = Field(default_factory=list)
+    pack_suggestions: list[str] = Field(default_factory=list)
+
+
+class ClassificationResponse(BaseModel):
+    category: str
+    confidence: float
+    all_scores: dict[str, float]
+    raw_logits: dict[str, float] = Field(default_factory=dict)
+    top_labels: list[TopLabelEntry] = Field(default_factory=list)
+    entropy: float
+    entropy_top_k: float = 0.0
+    entropy_normalized: float = 0.0
+    confidence_margin: float
+    nsfw_score: float
+    is_nsfw: bool
+    ambiguous: bool
+    affinity_weight: float
+    affinity_weight_raw: float = 0.0
+    llm_expansion_used: bool = False
+    llm_expansion_gate_reason: str = "enabled"
+    llm_expansion: LlmExpansionPayload = Field(default_factory=LlmExpansionPayload)
+    similar_images: list[SimilarImageEntry] = Field(default_factory=list)
+    image_hash: str | None = None
+    model: str
+    device: str
+    labels: list[str]
+    filename: str | None = None
+    content_type: str | None = None
+
+
+class FeedbackRequest(BaseModel):
+    image_hash: str
+    theme: str
+    accepted: bool = True
+    asset_id: str | None = None
+
+
+class FeedbackResponse(BaseModel):
+    ok: bool
+
+
+def _parse_labels(raw: str | None) -> list[str] | None:
+    if raw is None:
+        return None
+
+    value = raw.strip()
+    if not value:
+        return None
+
+    if value.startswith("["):
+        try:
+            parsed = json.loads(value)
+        except json.JSONDecodeError as error:
+            raise HTTPException(status_code=422, detail=f"labels JSON inválido: {error.msg}") from error
+
+        if not isinstance(parsed, list):
+            raise HTTPException(status_code=422, detail="labels JSON deve ser uma lista de strings.")
+        return [str(item).strip() for item in parsed if str(item).strip()]
+
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+@app.get("/health")
+def health() -> dict[str, Any]:
+    runtime = get_classifier().runtime_info
+    return {
+        "ok": True,
+        "status": "ready",
+        "model": runtime.model_name,
+        "device": runtime.device,
+    }
+
+
+@app.get("/labels")
+def labels() -> dict[str, Any]:
+    return {
+        "ok": True,
+        "default_labels": DEFAULT_LABELS,
+        "nsfw_threshold": NSFW_THRESHOLD,
+        "top_k": CLIP_TOP_K,
+        "entropy_threshold": ENTROPY_THRESHOLD,
+        "entropy_normalized_threshold": ENTROPY_NORMALIZED_THRESHOLD,
+        "adaptive_alpha": ADAPTIVE_ALPHA,
+        "affinity_weight_cap": AFFINITY_WEIGHT_CAP,
+        "llm_expansion_min_margin": LLM_EXPANSION_MIN_MARGIN,
+        "llm_expansion_max_entropy_normalized": LLM_EXPANSION_MAX_ENTROPY_NORMALIZED,
+        "features": {
+            "embedding_cache": ENABLE_EMBEDDING_CACHE,
+            "clustering": ENABLE_CLUSTERING,
+            "adaptive_scoring": ENABLE_ADAPTIVE_SCORING,
+            "llm_label_expansion": ENABLE_LLM_LABEL_EXPANSION,
+            "llm_expansion_gating": ENABLE_LLM_EXPANSION_GATING,
+        },
+    }
+
+
+@app.post("/classify", response_model=ClassificationResponse)
+async def classify(
+    file: UploadFile = File(...),
+    labels: str | None = Form(None),
+    nsfw_threshold: float = Form(NSFW_THRESHOLD),
+    asset_id: str | None = Form(None),
+    asset_sha256: str | None = Form(None),
+    theme: str | None = Form(None),
+    similar_threshold: float | None = Form(None),
+    similar_limit: int | None = Form(None),
+) -> ClassificationResponse:
+    if not file.filename:
+        raise HTTPException(status_code=422, detail="Arquivo sem nome.")
+
+    if file.content_type and not file.content_type.lower().startswith("image/"):
+        raise HTTPException(status_code=415, detail=f"Tipo de arquivo não suportado: {file.content_type}")
+
+    file_bytes = await file.read()
+    custom_labels = _parse_labels(labels)
+
+    try:
+        result = classify_image_bytes(
+            file_bytes,
+            labels=custom_labels,
+            nsfw_threshold=nsfw_threshold,
+            asset_id=(asset_id or None),
+            asset_sha256=(asset_sha256 or None),
+            theme=(theme or None),
+            similar_threshold=similar_threshold,
+            similar_limit=similar_limit,
+        )
+    except ValueError as error:
+        raise HTTPException(status_code=422, detail=str(error)) from error
+    except Exception as error:
+        raise HTTPException(status_code=500, detail=f"Falha interna na classificação: {error}") from error
+
+    runtime = get_classifier().runtime_info
+    return ClassificationResponse(
+        **result,
+        model=runtime.model_name,
+        device=runtime.device,
+        labels=custom_labels or list(DEFAULT_LABELS),
+        filename=file.filename,
+        content_type=file.content_type,
+    )
+
+
+@app.post("/feedback", response_model=FeedbackResponse)
+def feedback(payload: FeedbackRequest) -> FeedbackResponse:
+    if not payload.image_hash.strip():
+        raise HTTPException(status_code=422, detail="image_hash é obrigatório.")
+    if not payload.theme.strip():
+        raise HTTPException(status_code=422, detail="theme é obrigatório.")
+
+    try:
+        register_pack_feedback(
+            image_hash=payload.image_hash.strip().lower(),
+            theme=payload.theme.strip(),
+            accepted=bool(payload.accepted),
+            asset_id=payload.asset_id,
+        )
+    except Exception as error:
+        raise HTTPException(status_code=500, detail=f"Falha ao registrar feedback: {error}") from error
+
+    return FeedbackResponse(ok=True)

package/ml/clip_classifier/requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.116.1
+uvicorn[standard]==0.35.0
+python-multipart==0.0.22
+Pillow==12.1.1
+numpy==2.3.2
+torch==2.8.0
+open-clip-torch>=2.26.1
+python-dotenv>=1.0.1
+PyMySQL>=1.1.1
+openai>=1.63.0

package/ml/clip_classifier/similarity_engine.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from embedding_store import EmbeddingStore
+
+
+def cosine_similarity_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Compute pairwise cosine similarity between 2-D arrays."""
+    if a.ndim != 2 or b.ndim != 2:
+        raise ValueError("cosine_similarity_matrix requires 2-D arrays")
+    if a.shape[1] != b.shape[1]:
+        raise ValueError("Embedding dimensions must match")
+
+    a_norm = np.linalg.norm(a, axis=1, keepdims=True)
+    b_norm = np.linalg.norm(b, axis=1, keepdims=True)
+
+    a_safe = a / np.clip(a_norm, 1e-12, None)
+    b_safe = b / np.clip(b_norm, 1e-12, None)
+    return a_safe @ b_safe.T
+
+
+def find_similar_images(
+    *,
+    store: EmbeddingStore,
+    image_embedding: np.ndarray,
+    model_name: str,
+    threshold: float = 0.85,
+    limit: int = 25,
+    scan_limit: int = 3000,
+    source_image_hash: str | None = None,
+) -> list[dict[str, Any]]:
+    """Find semantically similar images from persisted embedding cache."""
+    if image_embedding.ndim != 1:
+        image_embedding = image_embedding.reshape(-1)
+
+    rows = store.list_image_embeddings(model_name=model_name, limit=scan_limit)
+    if not rows:
+        return []
+
+    candidates = []
+    vectors = []
+    for row in rows:
+        if source_image_hash and row.image_hash == source_image_hash:
+            continue
+        if row.embedding.size == 0:
+            continue
+        candidates.append(row)
+        vectors.append(row.embedding)
+
+    if not vectors:
+        return []
+
+    matrix_a = np.asarray([image_embedding.astype(np.float32)], dtype=np.float32)
+    matrix_b = np.asarray(vectors, dtype=np.float32)
+    scores = cosine_similarity_matrix(matrix_a, matrix_b).reshape(-1)
+
+    hits = []
+    for idx, score in enumerate(scores.tolist()):
+        if float(score) < float(threshold):
+            continue
+        candidate = candidates[idx]
+        hits.append(
+            {
+                "image_hash": candidate.image_hash,
+                "asset_id": candidate.asset_id,
+                "similarity": round(float(score), 6),
+            }
+        )
+
+    hits.sort(key=lambda entry: float(entry["similarity"]), reverse=True)
+    return hits[: max(1, min(int(limit or 25), 100))]

package/observability/alert-rules.yml

@@ -0,0 +1,60 @@
+groups:
+  - name: omnizap-db
+    rules:
+      - alert: OmniZapDBQueryOver500ms
+        expr: increase(omnizap_db_query_over_ms_total{threshold="500"}[5m]) > 0
+        for: 2m
+        labels:
+          severity: warning
+        annotations:
+          summary: "Query acima de 500ms detectada"
+          description: "Uma ou mais queries excederam 500ms nos últimos 5 minutos."
+
+      - alert: OmniZapLidMapUpsertOver1000ms
+        expr: increase(omnizap_db_query_over_ms_total{threshold="1000",table="lid_map"}[5m]) > 0
+        for: 2m
+        labels:
+          severity: critical
+        annotations:
+          summary: "UPSERT lid_map acima de 1000ms"
+          description: "UPSERTs em lid_map excederam 1000ms nos últimos 5 minutos."
+
+      - alert: OmniZapMySQLLockWaitsHigh
+        expr: rate(mysql_global_status_innodb_row_lock_waits[5m]) > 5
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: "Lock waits elevados no InnoDB"
+          description: "Taxa de lock waits acima de 5/s nos últimos 5 minutos."
+
+  - name: omnizap-queues
+    rules:
+      - alert: OmniZapMessageQueueHigh
+        expr: omnizap_queue_depth{queue="messages"} > 2000
+        for: 5m
+        labels:
+          severity: warning
+        annotations:
+          summary: "Fila de mensagens alta"
+          description: "Backlog da fila de mensagens acima de 2000."
+
+  - name: omnizap-host
+    rules:
+      - alert: OmniZapDiskUsageHigh
+        expr: (1 - (node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes{fstype!~"tmpfs|overlay"})) > 0.80
+        for: 10m
+        labels:
+          severity: critical
+        annotations:
+          summary: "Disco acima de 80%"
+          description: "Uso de disco acima de 80% por 10 minutos."
+
+      - alert: OmniZapMemoryUsageHigh
+        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) > 0.80
+        for: 10m
+        labels:
+          severity: warning
+        annotations:
+          summary: "Memória acima de 80%"
+          description: "Uso de memória acima de 80% por 10 minutos."

package/observability/grafana/dashboards/omnizap-mysql.json

@@ -0,0 +1,136 @@
+{
+  "uid": "omnizap-mysql",
+  "title": "OmniZap MySQL",
+  "timezone": "browser",
+  "schemaVersion": 38,
+  "version": 3,
+  "refresh": "10s",
+  "time": {
+    "from": "now-6h",
+    "to": "now"
+  },
+  "tags": ["omnizap", "mysql"],
+  "panels": [
+    {
+      "type": "timeseries",
+      "title": "Queries/sec",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 0, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(mysql_global_status_queries[5m])",
+          "legendFormat": "qps",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Writes/sec",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 8, "y": 0, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "sum(rate(mysql_global_status_commands_total{command=~\"insert|update|delete\"}[5m])) or (sum(rate(mysql_global_status_com_insert[5m])) + sum(rate(mysql_global_status_com_update[5m])) + sum(rate(mysql_global_status_com_delete[5m]))) or vector(0)",
+          "legendFormat": "writes",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Slow Queries/sec",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 16, "y": 0, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(mysql_global_status_slow_queries[5m])",
+          "legendFormat": "slow",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "InnoDB Row Lock Waits/sec",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 8, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(mysql_global_status_innodb_row_lock_waits[5m])",
+          "legendFormat": "waits",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "InnoDB Row Lock Time (ms/sec)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 8, "y": 8, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(mysql_global_status_innodb_row_lock_time[5m])",
+          "legendFormat": "lock_time",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Buffer Pool Hit Ratio",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 16, "y": 8, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "1 - (rate(mysql_global_status_innodb_buffer_pool_reads[5m]) / rate(mysql_global_status_innodb_buffer_pool_read_requests[5m]))",
+          "legendFormat": "hit_ratio",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "InnoDB IO (bytes/sec)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 16, "w": 12, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(mysql_global_status_innodb_data_read[5m])",
+          "legendFormat": "read",
+          "refId": "A"
+        },
+        {
+          "expr": "rate(mysql_global_status_innodb_data_written[5m])",
+          "legendFormat": "write",
+          "refId": "B"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Table Latency P99 (ms)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 12, "y": 16, "w": 12, "h": 8 },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(omnizap_db_query_duration_ms_bucket[5m])) by (le, table))",
+          "legendFormat": "{{table}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "logs",
+      "title": "MySQL Slow Log",
+      "datasource": "Loki",
+      "gridPos": { "x": 0, "y": 24, "w": 24, "h": 10 },
+      "targets": [
+        {
+          "expr": "{job=\"mysql-slow\"}",
+          "refId": "A"
+        }
+      ]
+    }
+  ]
+}

package/observability/grafana/dashboards/omnizap-overview.json

@@ -0,0 +1,170 @@
+{
+  "uid": "omnizap-overview",
+  "title": "OmniZap Overview",
+  "timezone": "browser",
+  "schemaVersion": 38,
+  "version": 1,
+  "refresh": "10s",
+  "time": {
+    "from": "now-6h",
+    "to": "now"
+  },
+  "tags": ["omnizap", "overview"],
+  "panels": [
+    {
+      "type": "timeseries",
+      "title": "Messages/sec",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 0, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(omnizap_messages_upsert_messages_total[1m])",
+          "legendFormat": "{{type}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "messages.upsert P99 (ms)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 8, "y": 0, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(omnizap_messages_upsert_duration_ms_bucket[5m])) by (le))",
+          "legendFormat": "p99",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Queue Depth",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 16, "y": 0, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "omnizap_queue_depth",
+          "legendFormat": "{{queue}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "DB Query P99 by Table (ms)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 8, "w": 12, "h": 9 },
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(omnizap_db_query_duration_ms_bucket[5m])) by (le, table))",
+          "legendFormat": "{{table}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "DB Errors/s",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 12, "y": 8, "w": 6, "h": 9 },
+      "targets": [
+        {
+          "expr": "rate(omnizap_errors_total{scope=\"db\"}[5m])",
+          "legendFormat": "db",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "DB Slow Queries (>=500ms)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 18, "y": 8, "w": 6, "h": 9 },
+      "targets": [
+        {
+          "expr": "increase(omnizap_db_query_over_ms_total{threshold=\"500\"}[5m])",
+          "legendFormat": "{{table}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "CPU Usage %",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 17, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)",
+          "legendFormat": "cpu",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Memory Usage %",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 8, "y": 17, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100",
+          "legendFormat": "memory",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Disk Usage %",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 16, "y": 17, "w": 8, "h": 8 },
+      "targets": [
+        {
+          "expr": "(1 - (node_filesystem_avail_bytes{fstype!~\"tmpfs|overlay\"} / node_filesystem_size_bytes{fstype!~\"tmpfs|overlay\"})) * 100",
+          "legendFormat": "{{mountpoint}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Writes/sec by Table",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 0, "y": 25, "w": 12, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(omnizap_db_write_total[5m])",
+          "legendFormat": "{{operation}} {{table}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "timeseries",
+      "title": "Inserts/Upserts/sec (messages, chats, lid_map)",
+      "datasource": "Prometheus",
+      "gridPos": { "x": 12, "y": 25, "w": 12, "h": 8 },
+      "targets": [
+        {
+          "expr": "rate(omnizap_db_write_total{operation=~\"insert|upsert\",table=~\"messages|chats|lid_map\"}[5m])",
+          "legendFormat": "{{operation}} {{table}}",
+          "refId": "A"
+        }
+      ]
+    },
+    {
+      "type": "logs",
+      "title": "Top Slow Queries (Loki)",
+      "datasource": "Loki",
+      "gridPos": { "x": 0, "y": 33, "w": 24, "h": 10 },
+      "targets": [
+        {
+          "expr": "{job=\"db-monitor\"} |= \"slow\" | json | line_format \"{{.ts}} {{.durationMs}}ms {{.table}} {{.normalizedSql}}\"",
+          "refId": "A"
+        }
+      ]
+    }
+  ]
+}

package/observability/grafana/provisioning/dashboards/dashboards.yml

@@ -0,0 +1,11 @@
+apiVersion: 1
+
+providers:
+  - name: omnizap
+    orgId: 1
+    folder: "OmniZap"
+    type: file
+    disableDeletion: false
+    updateIntervalSeconds: 30
+    options:
+      path: /var/lib/grafana/dashboards

package/observability/grafana/provisioning/datasources/datasources.yml

@@ -0,0 +1,15 @@
+apiVersion: 1
+
+datasources:
+  - name: Prometheus
+    type: prometheus
+    access: proxy
+    url: http://prometheus:9090
+    isDefault: true
+    editable: false
+
+  - name: Loki
+    type: loki
+    access: proxy
+    url: http://loki:3100
+    editable: false