Initial deployment: Sentiment & Topic Analysis Dashboard

Full-stack app with FastAPI backend + React TypeScript frontend.
ML-powered multilingual sentiment analysis, topic clustering,
anomaly detection, and interactive visualizations.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Dockerfile

@@ -0,0 +1,51 @@
+FROM node:20-alpine AS frontend-build
+
+WORKDIR /frontend
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm ci
+COPY frontend/ .
+RUN npm run build
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Create non-root user (required by HF Spaces)
+RUN useradd -m -u 1000 appuser
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY backend/requirements.txt .
+
+# Install CPU-only torch first (much smaller), skip problematic deps
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu && \
+    pip install --no-cache-dir \
+    $(grep -v '^#' requirements.txt | grep -v '^$' | grep -v '^torch==' | grep -v 'pycld3' | grep -v 'weasyprint' | tr '\n' ' ') && \
+    pip install --no-cache-dir reportlab
+
+COPY backend/ .
+
+# Copy frontend build into backend static dir
+COPY --from=frontend-build /frontend/dist /app/static
+
+# Copy demo data
+COPY demo_data/ /app/demo_data/
+
+RUN mkdir -p uploads model_cache data && \
+    chown -R appuser:appuser /app
+
+ENV PORT=7860
+ENV APP_ENV=production
+ENV LOG_LEVEL=INFO
+ENV TRANSFORMERS_CACHE=/app/model_cache
+ENV SENTENCE_TRANSFORMERS_HOME=/app/model_cache
+ENV HF_HOME=/app/model_cache
+
+USER appuser
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+

README.md

@@ -5,6 +5,30 @@ colorFrom: green
 colorTo: blue
 sdk: docker
 pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📊 Sentiment & Topic Analysis Dashboard
+
+Upload CSV, JSON, or Excel files containing customer feedback, support tickets, or reviews — get instant multilingual sentiment analysis, topic clustering, anomaly detection, and interactive visualizations.
+
+## Features
+- **Multilingual sentiment analysis** using `cardiffnlp/twitter-xlm-roberta-base-sentiment`
+- **Dynamic topic clustering** with BERTopic (HDBSCAN + UMAP)
+- **Interactive force-directed** topic cluster graph
+- **Sentiment trend charts** with confidence intervals
+- **Data quality dashboard** flagging low-confidence predictions, mixed languages, duplicates
+- **Comparison mode** to contrast time periods or segments
+- **Export** to CSV, JSON, or PDF
+- **Dark mode** support
+
+## Usage
+1. Upload a file with text data (CSV, JSON, Excel)
+2. Wait for analysis to complete (~30s for 50 entries)
+3. Explore the dashboard tabs: Overview, Data Quality, Compare
+
+**API Key**: Use `dev-key-1` (pre-configured in the UI)
+
+## Tech Stack
+- **Backend**: FastAPI, PyTorch, Transformers, BERTopic
+- **Frontend**: React, TypeScript, Recharts, D3.js

backend/Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p uploads model_cache data
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
+    CMD python -c "import httpx; r = httpx.get('http://localhost:8000/health/live'); r.raise_for_status()"
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

backend/app/api/analysis.py

@@ -0,0 +1,290 @@
+"""Upload and analysis API endpoints."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Optional
+
+from fastapi import APIRouter, BackgroundTasks, Depends, File, HTTPException, Query, UploadFile
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.core.security import get_api_key
+from app.models.schemas import (
+    AnalysisResult,
+    AnalysisStatus,
+    ComparisonRequest,
+    ComparisonResult,
+    FilterParams,
+    JobStatus,
+    TopicInfo,
+)
+from app.services.analysis_pipeline import (
+    filter_entries,
+    get_all_jobs,
+    get_job,
+    run_analysis,
+)
+from app.services.file_processing import parse_file
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/api/v1", tags=["analysis"])
+
+
+@router.post("/upload", response_model=JobStatus)
+async def upload_file(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    source: Optional[str] = Query(None, description="Data source label"),
+    api_key: str = Depends(get_api_key),
+):
+    """Upload a file for analysis. Supports CSV, JSON, Excel, ZIP."""
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="No filename provided")
+
+    content = await file.read()
+    size_mb = len(content) / (1024 * 1024)
+
+    if size_mb > settings.max_upload_size_mb:
+        raise HTTPException(
+            status_code=413,
+            detail=f"File too large ({size_mb:.1f}MB). Maximum: {settings.max_upload_size_mb}MB",
+        )
+
+    try:
+        entries = parse_file(content, file.filename, source)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    if not entries:
+        raise HTTPException(status_code=400, detail="No valid entries found in the uploaded file")
+
+    job_id = uuid.uuid4().hex[:12]
+    logger.info("upload_received", job_id=job_id, filename=file.filename, entries=len(entries), size_mb=round(size_mb, 2))
+
+    background_tasks.add_task(run_analysis, entries, job_id)
+
+    from datetime import datetime
+
+    return JobStatus(
+        job_id=job_id,
+        status=AnalysisStatus.PENDING,
+        progress=0.0,
+        message=f"Processing {len(entries)} entries from {file.filename}",
+        created_at=datetime.utcnow(),
+    )
+
+
+@router.post("/upload/chunked", response_model=JobStatus)
+async def upload_chunked(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    chunk_index: int = Query(0, ge=0),
+    total_chunks: int = Query(1, ge=1),
+    upload_id: Optional[str] = Query(None),
+    source: Optional[str] = Query(None),
+    api_key: str = Depends(get_api_key),
+):
+    """Chunked upload for files >10MB."""
+    from pathlib import Path
+
+    upload_id = upload_id or uuid.uuid4().hex[:12]
+    chunk_dir = settings.upload_path / f"chunks_{upload_id}"
+    chunk_dir.mkdir(parents=True, exist_ok=True)
+
+    content = await file.read()
+    chunk_path = chunk_dir / f"chunk_{chunk_index:04d}"
+    chunk_path.write_bytes(content)
+
+    logger.info("chunk_received", upload_id=upload_id, chunk=chunk_index, total=total_chunks)
+
+    if chunk_index + 1 < total_chunks:
+        from datetime import datetime
+
+        return JobStatus(
+            job_id=upload_id,
+            status=AnalysisStatus.PENDING,
+            progress=chunk_index / total_chunks,
+            message=f"Received chunk {chunk_index + 1}/{total_chunks}",
+            created_at=datetime.utcnow(),
+        )
+
+    # All chunks received — reassemble
+    chunks = sorted(chunk_dir.glob("chunk_*"))
+    combined = b"".join(c.read_bytes() for c in chunks)
+
+    # Clean up chunks
+    for c in chunks:
+        c.unlink()
+    chunk_dir.rmdir()
+
+    try:
+        filename = file.filename or "upload.csv"
+        entries = parse_file(combined, filename, source)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    if not entries:
+        raise HTTPException(status_code=400, detail="No valid entries found")
+
+    background_tasks.add_task(run_analysis, entries, upload_id)
+
+    from datetime import datetime
+
+    return JobStatus(
+        job_id=upload_id,
+        status=AnalysisStatus.PROCESSING,
+        progress=0.0,
+        message=f"All chunks received. Processing {len(entries)} entries.",
+        created_at=datetime.utcnow(),
+    )
+
+
+@router.get("/jobs", response_model=list[JobStatus])
+async def list_jobs(api_key: str = Depends(get_api_key)):
+    """List all analysis jobs."""
+    jobs = get_all_jobs()
+    return [
+        JobStatus(
+            job_id=j.job_id,
+            status=j.status,
+            progress=1.0 if j.status == AnalysisStatus.COMPLETED else 0.5,
+            message="",
+            created_at=j.created_at,
+            completed_at=j.completed_at,
+        )
+        for j in jobs
+    ]
+
+
+@router.get("/jobs/{job_id}", response_model=AnalysisResult)
+async def get_job_result(job_id: str, api_key: str = Depends(get_api_key)):
+    """Get analysis results for a specific job."""
+    job = get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+    return job
+
+
+@router.get("/jobs/{job_id}/status", response_model=JobStatus)
+async def get_job_status(job_id: str, api_key: str = Depends(get_api_key)):
+    """Get status of an analysis job."""
+    job = get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+    return JobStatus(
+        job_id=job.job_id,
+        status=job.status,
+        progress=1.0 if job.status == AnalysisStatus.COMPLETED else 0.5,
+        message="",
+        created_at=job.created_at,
+        completed_at=job.completed_at,
+    )
+
+
+@router.post("/jobs/{job_id}/filter")
+async def filter_job_results(
+    job_id: str,
+    filters: FilterParams,
+    api_key: str = Depends(get_api_key),
+):
+    """Filter analysis results."""
+    job = get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+    if job.status != AnalysisStatus.COMPLETED:
+        raise HTTPException(status_code=400, detail="Analysis not yet completed")
+
+    filtered = filter_entries(
+        job.entries,
+        date_from=filters.date_from,
+        date_to=filters.date_to,
+        sentiment_min=filters.sentiment_min,
+        sentiment_max=filters.sentiment_max,
+        topics=filters.topics,
+        languages=filters.languages,
+        sources=filters.sources,
+        search_text=filters.search_text,
+    )
+
+    # Paginate
+    start = (filters.page - 1) * filters.page_size
+    end = start + filters.page_size
+
+    return {
+        "total": len(filtered),
+        "page": filters.page,
+        "page_size": filters.page_size,
+        "entries": filtered[start:end],
+    }
+
+
+@router.post("/jobs/{job_id}/compare", response_model=ComparisonResult)
+async def compare_segments(
+    job_id: str,
+    comparison: ComparisonRequest,
+    api_key: str = Depends(get_api_key),
+):
+    """Compare two data segments from the same job."""
+    job = get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+    if job.status != AnalysisStatus.COMPLETED:
+        raise HTTPException(status_code=400, detail="Analysis not yet completed")
+
+    from collections import Counter
+
+    import numpy as np
+
+    from app.models.schemas import AnalysisSummary, SentimentLabel
+
+    seg_a_entries = filter_entries(
+        job.entries, **comparison.segment_a.model_dump(exclude={"page", "page_size"})
+    )
+    seg_b_entries = filter_entries(
+        job.entries, **comparison.segment_b.model_dump(exclude={"page", "page_size"})
+    )
+
+    def make_summary(entries):
+        if not entries:
+            return AnalysisSummary(
+                total_entries=0, avg_sentiment=0.5,
+                dominant_sentiment=SentimentLabel.NEUTRAL,
+                num_topics=0, top_topics=[], languages_detected=[],
+            )
+        sentiments = [e.sentiment for e in entries]
+        topic_counts = Counter(e.topic_id for e in entries)
+        return AnalysisSummary(
+            total_entries=len(entries),
+            avg_sentiment=round(float(np.mean([s.score for s in sentiments])), 4),
+            dominant_sentiment=SentimentLabel(
+                Counter(s.label.value for s in sentiments).most_common(1)[0][0]
+            ),
+            num_topics=len(set(e.topic_id for e in entries) - {-1}),
+            top_topics=[
+                TopicInfo(topic_id=tid, label=f"Topic {tid}", keywords=[], size=cnt)
+                for tid, cnt in topic_counts.most_common(5) if tid != -1
+            ],
+            languages_detected=list(set(e.language.language for e in entries)),
+        )
+
+    sum_a = make_summary(seg_a_entries)
+    sum_b = make_summary(seg_b_entries)
+
+    topics_a = set(e.topic_id for e in seg_a_entries) - {-1}
+    topics_b = set(e.topic_id for e in seg_b_entries) - {-1}
+
+    return ComparisonResult(
+        segment_a=sum_a,
+        segment_b=sum_b,
+        sentiment_delta=round(sum_b.avg_sentiment - sum_a.avg_sentiment, 4),
+        topic_changes=[],
+        new_topics=[
+            TopicInfo(topic_id=t, label=f"Topic {t}", keywords=[], size=0)
+            for t in topics_b - topics_a
+        ],
+        disappeared_topics=[
+            TopicInfo(topic_id=t, label=f"Topic {t}", keywords=[], size=0)
+            for t in topics_a - topics_b
+        ],
+    )

backend/app/api/export.py

@@ -0,0 +1,75 @@
+"""Export API endpoints."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import Response
+
+from app.core.security import get_api_key
+from app.models.schemas import AnalysisStatus, ExportFormat, FilterParams
+from app.services.analysis_pipeline import filter_entries, get_job
+from app.services.export import export_entries
+
+router = APIRouter(prefix="/api/v1", tags=["export"])
+
+
+CONTENT_TYPES = {
+    ExportFormat.CSV: "text/csv",
+    ExportFormat.JSON: "application/json",
+    ExportFormat.PDF: "application/pdf",
+}
+
+FILE_EXTENSIONS = {
+    ExportFormat.CSV: "csv",
+    ExportFormat.JSON: "json",
+    ExportFormat.PDF: "pdf",
+}
+
+
+@router.post("/jobs/{job_id}/export")
+async def export_results(
+    job_id: str,
+    fmt: ExportFormat = ExportFormat.CSV,
+    filters: FilterParams | None = None,
+    api_key: str = Depends(get_api_key),
+):
+    """Export filtered analysis results."""
+    job = get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+    if job.status != AnalysisStatus.COMPLETED:
+        raise HTTPException(status_code=400, detail="Analysis not yet completed")
+
+    entries = job.entries
+    if filters:
+        entries = filter_entries(
+            entries,
+            date_from=filters.date_from,
+            date_to=filters.date_to,
+            sentiment_min=filters.sentiment_min,
+            sentiment_max=filters.sentiment_max,
+            topics=filters.topics,
+            languages=filters.languages,
+            sources=filters.sources,
+            search_text=filters.search_text,
+        )
+
+    summary = None
+    if job.summary:
+        summary = {
+            "Total Entries": job.summary.total_entries,
+            "Average Sentiment": job.summary.avg_sentiment,
+            "Dominant Sentiment": job.summary.dominant_sentiment.value,
+            "Topics Found": job.summary.num_topics,
+            "Languages": ", ".join(job.summary.languages_detected),
+        }
+
+    content = export_entries(entries, fmt, summary)
+
+    return Response(
+        content=content,
+        media_type=CONTENT_TYPES[fmt],
+        headers={
+            "Content-Disposition": f"attachment; filename=analysis_{job_id}.{FILE_EXTENSIONS[fmt]}"
+        },
+    )

backend/app/api/health.py

@@ -0,0 +1,42 @@
+"""Health and system endpoints."""
+
+from __future__ import annotations
+
+import time
+
+from fastapi import APIRouter
+
+from app.core.config import settings
+from app.models.schemas import HealthResponse
+from app.services.redis_client import check_redis_health
+from app.services.sentiment import is_model_available
+
+router = APIRouter(tags=["system"])
+
+_start_time = time.time()
+
+
+@router.get("/health", response_model=HealthResponse)
+async def health_check():
+    redis_ok = await check_redis_health()
+    return HealthResponse(
+        status="healthy" if redis_ok else "degraded",
+        version="1.0.0",
+        models_loaded=is_model_available(),
+        redis_connected=redis_ok,
+        uptime_seconds=round(time.time() - _start_time, 2),
+    )
+
+
+@router.get("/health/live")
+async def liveness():
+    return {"status": "alive"}
+
+
+@router.get("/health/ready")
+async def readiness():
+    redis_ok = await check_redis_health()
+    if not redis_ok:
+        from fastapi import HTTPException
+        raise HTTPException(status_code=503, detail="Redis not available")
+    return {"status": "ready"}

backend/app/api/webhooks.py

@@ -0,0 +1,107 @@
+"""Webhook and SSE endpoints for real-time ingestion."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime
+
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request
+from sse_starlette.sse import EventSourceResponse
+
+from app.core.logging import get_logger
+from app.core.security import get_api_key, verify_webhook_signature
+from app.models.schemas import AnalysisStatus, FeedbackEntry, JobStatus, WebhookPayload
+from app.services.analysis_pipeline import run_analysis
+from app.services.redis_client import subscribe_events
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/api/v1", tags=["realtime"])
+
+
+@router.post("/webhooks/ingest", response_model=JobStatus)
+async def webhook_ingest(
+    request: Request,
+    background_tasks: BackgroundTasks,
+):
+    """Receive data via webhook with Stripe-style signature verification."""
+    body = await request.body()
+    signature = request.headers.get("X-Signature", "")
+    timestamp = request.headers.get("X-Timestamp", "")
+
+    if not verify_webhook_signature(body, signature, timestamp):
+        raise HTTPException(status_code=401, detail="Invalid webhook signature")
+
+    try:
+        payload = WebhookPayload.model_validate_json(body)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid payload: {exc}")
+
+    if not payload.data:
+        raise HTTPException(status_code=400, detail="No data entries in payload")
+
+    import uuid
+
+    job_id = uuid.uuid4().hex[:12]
+    logger.info("webhook_received", job_id=job_id, event=payload.event_type, entries=len(payload.data))
+
+    entries = [
+        FeedbackEntry(
+            id=e.id,
+            text=e.text,
+            source=payload.source or e.source or "webhook",
+            timestamp=e.timestamp or datetime.utcnow(),
+            metadata=e.metadata,
+        )
+        for e in payload.data
+    ]
+
+    background_tasks.add_task(run_analysis, entries, job_id)
+
+    return JobStatus(
+        job_id=job_id,
+        status=AnalysisStatus.PENDING,
+        progress=0.0,
+        message=f"Webhook: processing {len(entries)} entries",
+        created_at=datetime.utcnow(),
+    )
+
+
+@router.get("/events/analysis")
+async def analysis_events(request: Request, api_key: str = Depends(get_api_key)):
+    """Server-Sent Events stream for live analysis updates."""
+
+    async def event_generator():
+        try:
+            async for data in subscribe_events("analysis_updates"):
+                if await request.is_disconnected():
+                    break
+                yield {
+                    "event": "analysis_update",
+                    "data": json.dumps(data),
+                }
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:
+            logger.error("sse_error", error=str(exc))
+
+    return EventSourceResponse(event_generator())
+
+
+@router.get("/events/anomalies")
+async def anomaly_events(request: Request, api_key: str = Depends(get_api_key)):
+    """SSE stream for anomaly alerts."""
+
+    async def event_generator():
+        try:
+            async for data in subscribe_events("anomaly_alerts"):
+                if await request.is_disconnected():
+                    break
+                yield {
+                    "event": "anomaly_alert",
+                    "data": json.dumps(data),
+                }
+        except asyncio.CancelledError:
+            pass
+
+    return EventSourceResponse(event_generator())

backend/app/core/config.py

@@ -0,0 +1,103 @@
+"""Application configuration using pydantic-settings."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # Application
+    app_name: str = "TopicAnalysis"
+    app_env: str = "development"
+    debug: bool = False
+    secret_key: str = "change-me-in-production"
+    api_key_header: str = "X-API-Key"
+    allowed_api_keys: List[str] = ["dev-key-1"]
+
+    # Server
+    backend_host: str = "0.0.0.0"
+    backend_port: int = 8000
+    frontend_url: str = "http://localhost:3000"
+    cors_origins: List[str] = ["http://localhost:3000", "http://localhost:8080"]
+
+    # Redis
+    redis_url: str = "redis://localhost:6379/0"
+
+    # File Upload
+    max_upload_size_mb: int = 500
+    chunk_size_mb: int = 10
+    upload_dir: str = "./uploads"
+
+    # ML Models
+    sentiment_model: str = "cardiffnlp/twitter-xlm-roberta-base-sentiment"
+    embedding_model: str = "paraphrase-multilingual-MiniLM-L12-v2"
+    model_cache_dir: str = "./model_cache"
+    model_load_timeout: int = 120
+
+    # Rate Limiting
+    rate_limit_per_minute: int = 60
+    rate_limit_burst: int = 10
+
+    # Anomaly Detection
+    anomaly_rolling_window: int = 50
+    anomaly_sentiment_threshold: float = 1.5
+    anomaly_topic_spike_threshold: float = 3.0
+
+    # Notifications
+    slack_webhook_url: str = ""
+    notification_email_from: str = ""
+    notification_email_to: str = ""
+    smtp_host: str = ""
+    smtp_port: int = 587
+    smtp_user: str = ""
+    smtp_password: str = ""
+
+    # Webhook
+    webhook_secret: str = "whsec_change-me"
+
+    # Observability
+    otel_exporter_otlp_endpoint: str = "http://localhost:4317"
+    otel_service_name: str = "topic-analysis"
+    log_level: str = "INFO"
+    log_format: str = "json"
+
+    # Database
+    database_url: str = "sqlite:///./data/analysis.db"
+
+    @field_validator("allowed_api_keys", mode="before")
+    @classmethod
+    def parse_api_keys(cls, v: str | list) -> list:
+        if isinstance(v, str):
+            return [k.strip() for k in v.split(",") if k.strip()]
+        return v
+
+    @field_validator("cors_origins", mode="before")
+    @classmethod
+    def parse_cors(cls, v: str | list) -> list:
+        if isinstance(v, str):
+            return [o.strip() for o in v.split(",") if o.strip()]
+        return v
+
+    @property
+    def upload_path(self) -> Path:
+        p = Path(self.upload_dir)
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    @property
+    def is_production(self) -> bool:
+        return self.app_env == "production"
+
+
+settings = Settings()

backend/app/core/logging.py

@@ -0,0 +1,81 @@
+"""Structured logging with correlation IDs."""
+
+from __future__ import annotations
+
+import logging
+import sys
+import uuid
+from contextvars import ContextVar
+
+import structlog
+
+correlation_id_var: ContextVar[str] = ContextVar("correlation_id", default="")
+
+
+def get_correlation_id() -> str:
+    cid = correlation_id_var.get()
+    if not cid:
+        cid = uuid.uuid4().hex[:16]
+        correlation_id_var.set(cid)
+    return cid
+
+
+def add_correlation_id(
+    logger: structlog.types.WrappedLogger,
+    method_name: str,
+    event_dict: dict,
+) -> dict:
+    event_dict["correlation_id"] = get_correlation_id()
+    return event_dict
+
+
+def setup_logging(log_level: str = "INFO", log_format: str = "json") -> None:
+    shared_processors: list = [
+        structlog.contextvars.merge_contextvars,
+        add_correlation_id,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    if log_format == "json":
+        renderer = structlog.processors.JSONRenderer()
+    else:
+        renderer = structlog.dev.ConsoleRenderer()
+
+    structlog.configure(
+        processors=[
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+    formatter = structlog.stdlib.ProcessorFormatter(
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            renderer,
+        ],
+        foreign_pre_chain=shared_processors,
+    )
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.addHandler(handler)
+    root.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+    for name in ("uvicorn", "uvicorn.access", "uvicorn.error"):
+        lg = logging.getLogger(name)
+        lg.handlers.clear()
+        lg.propagate = True
+
+
+def get_logger(name: str | None = None) -> structlog.stdlib.BoundLogger:
+    return structlog.get_logger(name)

backend/app/core/middleware.py

@@ -0,0 +1,39 @@
+"""FastAPI middleware for correlation IDs, request logging, and error handling."""
+
+from __future__ import annotations
+
+import time
+import uuid
+
+from fastapi import FastAPI, Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from app.core.logging import correlation_id_var, get_logger
+
+logger = get_logger(__name__)
+
+
+class CorrelationIdMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        cid = request.headers.get("X-Correlation-ID", uuid.uuid4().hex[:16])
+        correlation_id_var.set(cid)
+        start = time.perf_counter()
+
+        response: Response = await call_next(request)
+
+        duration_ms = round((time.perf_counter() - start) * 1000, 2)
+        response.headers["X-Correlation-ID"] = cid
+        response.headers["X-Response-Time-Ms"] = str(duration_ms)
+
+        logger.info(
+            "request_completed",
+            method=request.method,
+            path=request.url.path,
+            status_code=response.status_code,
+            duration_ms=duration_ms,
+        )
+        return response
+
+
+def register_middleware(app: FastAPI) -> None:
+    app.add_middleware(CorrelationIdMiddleware)

backend/app/core/security.py

@@ -0,0 +1,63 @@
+"""Security utilities: API key validation, webhook signature verification, rate limiting."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+from typing import Optional
+
+from fastapi import HTTPException, Request, Security
+from fastapi.security import APIKeyHeader
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from app.core.config import settings
+
+api_key_header = APIKeyHeader(name=settings.api_key_header, auto_error=False)
+
+
+def get_api_key(api_key: Optional[str] = Security(api_key_header)) -> str:
+    if not api_key or api_key not in settings.allowed_api_keys:
+        raise HTTPException(status_code=403, detail="Invalid or missing API key")
+    return api_key
+
+
+def _key_func(request: Request) -> str:
+    api_key = request.headers.get(settings.api_key_header, "")
+    if api_key:
+        return api_key
+    return get_remote_address(request)
+
+
+limiter = Limiter(key_func=_key_func, default_limits=[f"{settings.rate_limit_per_minute}/minute"])
+
+
+def verify_webhook_signature(payload: bytes, signature: str, timestamp: str) -> bool:
+    """Verify Stripe-style webhook signature (t=timestamp,v1=signature)."""
+    if not signature or not timestamp:
+        return False
+
+    try:
+        ts = int(timestamp)
+    except (ValueError, TypeError):
+        return False
+
+    if abs(time.time() - ts) > 300:
+        return False
+
+    signed_payload = f"{timestamp}.{payload.decode('utf-8')}"
+    expected = hmac.new(
+        settings.webhook_secret.encode("utf-8"),
+        signed_payload.encode("utf-8"),
+        hashlib.sha256,
+    ).hexdigest()
+
+    parts = signature.split(",")
+    for part in parts:
+        if part.startswith("v1="):
+            sig_value = part[3:]
+            if hmac.compare_digest(expected, sig_value):
+                return True
+
+    return False

backend/app/core/telemetry.py

@@ -0,0 +1,46 @@
+"""OpenTelemetry and Prometheus instrumentation setup."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+from prometheus_fastapi_instrumentator import Instrumentator
+
+from app.core.config import settings
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def setup_telemetry(app: FastAPI) -> None:
+    """Initialize OpenTelemetry tracing and Prometheus metrics."""
+    # Prometheus metrics
+    Instrumentator(
+        should_group_status_codes=True,
+        should_ignore_untemplated=True,
+        excluded_handlers=["/health", "/metrics"],
+    ).instrument(app).expose(app, endpoint="/metrics")
+
+    # OpenTelemetry — only in production to avoid dev noise
+    if settings.is_production:
+        try:
+            from opentelemetry import trace
+            from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+                OTLPSpanExporter,
+            )
+            from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+            from opentelemetry.sdk.resources import Resource
+            from opentelemetry.sdk.trace import TracerProvider
+            from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+            resource = Resource.create({"service.name": settings.otel_service_name})
+            provider = TracerProvider(resource=resource)
+            exporter = OTLPSpanExporter(endpoint=settings.otel_exporter_otlp_endpoint)
+            provider.add_span_processor(BatchSpanProcessor(exporter))
+            trace.set_tracer_provider(provider)
+
+            FastAPIInstrumentor.instrument_app(app)
+            logger.info("opentelemetry_initialized")
+        except ImportError:
+            logger.warning("opentelemetry_not_available", detail="Install opentelemetry packages")
+        except Exception as exc:
+            logger.error("opentelemetry_setup_failed", error=str(exc))

backend/app/main.py

@@ -0,0 +1,103 @@
+"""FastAPI application entry point."""
+
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+
+from app.api import analysis, export, health, webhooks
+from app.core.config import settings
+from app.core.logging import get_logger, setup_logging
+from app.core.middleware import register_middleware
+from app.core.security import limiter
+from app.core.telemetry import setup_telemetry
+from app.services.redis_client import close_redis
+
+setup_logging(settings.log_level, settings.log_format)
+logger = get_logger(__name__)
+
+STATIC_DIR = Path(__file__).parent.parent / "static"
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info(
+        "application_starting",
+        app_name=settings.app_name,
+        env=settings.app_env,
+    )
+    settings.upload_path  # Ensure upload directory exists
+    yield
+    logger.info("application_shutting_down")
+    await close_redis()
+
+
+app = FastAPI(
+    title=settings.app_name,
+    description="Sentiment & Topic Analysis Dashboard API",
+    version="1.0.0",
+    lifespan=lifespan,
+    docs_url="/docs" if not settings.is_production else None,
+    redoc_url="/redoc" if not settings.is_production else None,
+)
+
+# Middleware
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+register_middleware(app)
+setup_telemetry(app)
+
+# Routes
+app.include_router(health.router)
+app.include_router(analysis.router)
+app.include_router(export.router)
+app.include_router(webhooks.router)
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    from app.core.logging import get_correlation_id
+
+    logger.error(
+        "unhandled_exception",
+        path=request.url.path,
+        error=str(exc),
+        exc_info=True,
+    )
+    return JSONResponse(
+        status_code=500,
+        content={
+            "detail": "Internal server error",
+            "correlation_id": get_correlation_id(),
+        },
+    )
+
+
+# Serve frontend static files in production (when static/ dir exists)
+if STATIC_DIR.is_dir():
+    app.mount("/assets", StaticFiles(directory=str(STATIC_DIR / "assets")), name="static-assets")
+
+    @app.get("/{full_path:path}")
+    async def serve_spa(full_path: str):
+        """Serve the SPA index.html for all non-API routes."""
+        file_path = STATIC_DIR / full_path
+        if file_path.is_file():
+            return FileResponse(str(file_path))
+        return FileResponse(str(STATIC_DIR / "index.html"))

backend/app/models/schemas.py

@@ -0,0 +1,240 @@
+"""Pydantic schemas for all data models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+# --- Enums ---
+
+
+class SentimentLabel(str, Enum):
+    POSITIVE = "positive"
+    NEGATIVE = "negative"
+    NEUTRAL = "neutral"
+
+
+class ExportFormat(str, Enum):
+    CSV = "csv"
+    JSON = "json"
+    PDF = "pdf"
+
+
+class AnomalyType(str, Enum):
+    SENTIMENT_DROP = "sentiment_drop"
+    TOPIC_SPIKE = "topic_spike"
+
+
+class AnalysisStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+# --- Request Models ---
+
+
+class FeedbackEntry(BaseModel):
+    id: Optional[str] = None
+    text: str = Field(..., min_length=1, max_length=50000)
+    source: Optional[str] = None
+    timestamp: Optional[datetime] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class AnalysisRequest(BaseModel):
+    entries: List[FeedbackEntry] = Field(..., min_items=1)
+    options: Optional[AnalysisOptions] = None
+
+
+class AnalysisOptions(BaseModel):
+    min_cluster_size: int = Field(default=5, ge=2, le=100)
+    min_samples: int = Field(default=3, ge=1, le=50)
+    detect_anomalies: bool = True
+    language_filter: Optional[str] = None
+
+
+class FilterParams(BaseModel):
+    date_from: Optional[datetime] = None
+    date_to: Optional[datetime] = None
+    sentiment_min: Optional[float] = Field(default=None, ge=-1.0, le=1.0)
+    sentiment_max: Optional[float] = Field(default=None, ge=-1.0, le=1.0)
+    topics: Optional[List[int]] = None
+    languages: Optional[List[str]] = None
+    sources: Optional[List[str]] = None
+    search_text: Optional[str] = None
+    page: int = Field(default=1, ge=1)
+    page_size: int = Field(default=50, ge=1, le=500)
+
+
+class ComparisonRequest(BaseModel):
+    segment_a: FilterParams
+    segment_b: FilterParams
+
+
+class WebhookPayload(BaseModel):
+    event_type: str
+    data: List[FeedbackEntry]
+    source: Optional[str] = None
+
+
+class AnomalyThresholds(BaseModel):
+    sentiment_threshold: float = Field(default=1.5, ge=0.1, le=5.0)
+    topic_spike_threshold: float = Field(default=3.0, ge=1.0, le=10.0)
+    rolling_window: int = Field(default=50, ge=10, le=1000)
+
+
+# --- Response Models ---
+
+
+class SentimentResult(BaseModel):
+    label: SentimentLabel
+    score: float = Field(..., ge=0.0, le=1.0)
+    confidence: float = Field(..., ge=0.0, le=1.0)
+
+
+class LanguageResult(BaseModel):
+    language: str
+    confidence: float = Field(..., ge=0.0, le=1.0)
+    method: str  # "langdetect" or "cld3"
+
+
+class TopicInfo(BaseModel):
+    topic_id: int
+    label: str
+    keywords: List[str]
+    size: int
+    representative_docs: List[str] = Field(default_factory=list)
+
+
+class AnalyzedEntry(BaseModel):
+    id: str
+    text: str
+    source: Optional[str] = None
+    timestamp: Optional[datetime] = None
+    sentiment: SentimentResult
+    language: LanguageResult
+    topic_id: int
+    topic_label: str
+    embedding: Optional[List[float]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class TopicCluster(BaseModel):
+    topic_id: int
+    label: str
+    keywords: List[str]
+    size: int
+    avg_sentiment: float
+    sentiment_distribution: Dict[str, int]
+    languages: Dict[str, int]
+    representative_docs: List[str]
+
+
+class SentimentTrend(BaseModel):
+    period: str
+    avg_sentiment: float
+    count: int
+    positive: int
+    negative: int
+    neutral: int
+    confidence_lower: float
+    confidence_upper: float
+
+
+class TopicLink(BaseModel):
+    source: int
+    target: int
+    weight: float
+
+
+class TopicGraph(BaseModel):
+    nodes: List[TopicCluster]
+    links: List[TopicLink]
+
+
+class DataQualityReport(BaseModel):
+    total_entries: int
+    low_confidence_count: int
+    low_confidence_entries: List[str]
+    mixed_language_count: int
+    mixed_language_entries: List[str]
+    duplicate_count: int
+    duplicate_entries: List[str]
+    avg_confidence: float
+    language_distribution: Dict[str, int]
+
+
+class AnomalyAlert(BaseModel):
+    id: str
+    type: AnomalyType
+    severity: str
+    message: str
+    detected_at: datetime
+    details: Dict[str, Any]
+
+
+class AnalysisResult(BaseModel):
+    job_id: str
+    status: AnalysisStatus
+    created_at: datetime
+    completed_at: Optional[datetime] = None
+    total_entries: int
+    entries: List[AnalyzedEntry] = Field(default_factory=list)
+    topics: List[TopicCluster] = Field(default_factory=list)
+    sentiment_trends: List[SentimentTrend] = Field(default_factory=list)
+    topic_graph: Optional[TopicGraph] = None
+    data_quality: Optional[DataQualityReport] = None
+    anomalies: List[AnomalyAlert] = Field(default_factory=list)
+    summary: Optional[AnalysisSummary] = None
+
+
+class AnalysisSummary(BaseModel):
+    total_entries: int
+    avg_sentiment: float
+    dominant_sentiment: SentimentLabel
+    num_topics: int
+    top_topics: List[TopicInfo]
+    languages_detected: List[str]
+    date_range: Optional[Dict[str, str]] = None
+
+
+class ComparisonResult(BaseModel):
+    segment_a: AnalysisSummary
+    segment_b: AnalysisSummary
+    sentiment_delta: float
+    topic_changes: List[Dict[str, Any]]
+    new_topics: List[TopicInfo]
+    disappeared_topics: List[TopicInfo]
+
+
+class JobStatus(BaseModel):
+    job_id: str
+    status: AnalysisStatus
+    progress: float = Field(default=0.0, ge=0.0, le=1.0)
+    message: str = ""
+    created_at: datetime
+    completed_at: Optional[datetime] = None
+
+
+class HealthResponse(BaseModel):
+    status: str
+    version: str
+    models_loaded: bool
+    redis_connected: bool
+    uptime_seconds: float
+
+
+class ErrorResponse(BaseModel):
+    detail: str
+    correlation_id: Optional[str] = None
+    code: Optional[str] = None
+
+
+# Fix forward references
+AnalysisRequest.model_rebuild()

backend/app/services/analysis_pipeline.py

@@ -0,0 +1,338 @@
+"""Analysis pipeline orchestrator — coordinates all ML services."""
+
+from __future__ import annotations
+
+import uuid
+from collections import Counter
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from app.core.logging import get_logger
+from app.models.schemas import (
+    AnalysisResult,
+    AnalysisSummary,
+    AnalysisStatus,
+    AnalyzedEntry,
+    FeedbackEntry,
+    SentimentLabel,
+    SentimentTrend,
+    TopicInfo,
+)
+from app.services.anomaly_detection import run_anomaly_detection
+from app.services.data_quality import analyze_data_quality
+from app.services.language_detection import detect_languages_batch
+from app.services.notifications import notify_anomalies
+from app.services.redis_client import publish_event
+from app.services.sentiment import (
+    analyze_sentiment,
+    get_fallback_sentiment,
+    is_model_available,
+)
+from app.services.topic_clustering import (
+    build_topic_graph,
+    cluster_topics,
+    compute_embeddings,
+    is_embedding_model_available,
+)
+
+logger = get_logger(__name__)
+
+# In-memory job store (production would use a database)
+_jobs: Dict[str, AnalysisResult] = {}
+
+
+async def run_analysis(
+    entries: list[FeedbackEntry],
+    job_id: Optional[str] = None,
+    detect_anomalies: bool = True,
+    min_cluster_size: Optional[int] = None,
+    min_samples: Optional[int] = None,
+) -> AnalysisResult:
+    """Run the full analysis pipeline."""
+    job_id = job_id or uuid.uuid4().hex[:12]
+    now = datetime.utcnow()
+
+    result = AnalysisResult(
+        job_id=job_id,
+        status=AnalysisStatus.PROCESSING,
+        created_at=now,
+        total_entries=len(entries),
+    )
+    _jobs[job_id] = result
+
+    await publish_event("analysis_updates", {"job_id": job_id, "status": "processing", "progress": 0.0})
+
+    try:
+        import time as _time
+
+        texts = [e.text for e in entries]
+        logger.info("pipeline_started", job_id=job_id, entry_count=len(texts),
+                     sample_text=texts[0][:100] if texts else "")
+
+        # Step 1: Language detection
+        t0 = _time.time()
+        logger.info("pipeline_step", step="language_detection", count=len(texts))
+        languages = detect_languages_batch(texts)
+        lang_counts = {}
+        for l in languages:
+            lang_counts[l.language] = lang_counts.get(l.language, 0) + 1
+        logger.info("language_detection_complete", elapsed=round(_time.time() - t0, 2),
+                     language_distribution=str(lang_counts))
+        await publish_event("analysis_updates", {"job_id": job_id, "status": "processing", "progress": 0.2})
+
+        # Step 2: Sentiment analysis
+        t0 = _time.time()
+        model_available = is_model_available()
+        logger.info("pipeline_step", step="sentiment_analysis", count=len(texts),
+                     model_available=model_available)
+        if model_available:
+            sentiments = await analyze_sentiment(texts)
+        else:
+            logger.warning("sentiment_model_unavailable_using_fallback",
+                           reason="ML model could not be loaded — using keyword fallback")
+            sentiments = [get_fallback_sentiment(t) for t in texts]
+
+        # Log sentiment distribution
+        sent_dist = {}
+        scores = [s.score for s in sentiments]
+        for s in sentiments:
+            sent_dist[s.label.value] = sent_dist.get(s.label.value, 0) + 1
+        logger.info("sentiment_analysis_complete",
+                     elapsed=round(_time.time() - t0, 2),
+                     distribution=str(sent_dist),
+                     avg_score=round(sum(scores) / len(scores), 4) if scores else 0,
+                     min_score=round(min(scores), 4) if scores else 0,
+                     max_score=round(max(scores), 4) if scores else 0,
+                     sample_label=sentiments[0].label.value if sentiments else "none",
+                     sample_score=sentiments[0].score if sentiments else 0)
+        await publish_event("analysis_updates", {"job_id": job_id, "status": "processing", "progress": 0.4})
+
+        # Step 3: Embeddings + Topic Clustering
+        t0 = _time.time()
+        logger.info("pipeline_step", step="topic_clustering", count=len(texts))
+        topic_assignments = [-1] * len(texts)
+        clusters = []
+        topic_graph = None
+        reduced_embeddings = None
+
+        if is_embedding_model_available() and len(texts) >= 5:
+            embeddings = await compute_embeddings(texts)
+            topic_assignments, clusters, reduced_embeddings = await cluster_topics(
+                texts, embeddings, min_cluster_size, min_samples
+            )
+
+            # Enrich clusters with sentiment/language data
+            for cluster in clusters:
+                indices = [i for i, t in enumerate(topic_assignments) if t == cluster.topic_id]
+                if indices:
+                    cluster_sentiments = [sentiments[i] for i in indices]
+                    cluster.avg_sentiment = round(
+                        np.mean([s.score for s in cluster_sentiments]), 4
+                    )
+                    cluster.sentiment_distribution = dict(
+                        Counter(s.label.value for s in cluster_sentiments)
+                    )
+                    cluster.languages = dict(
+                        Counter(languages[i].language for i in indices)
+                    )
+
+            topic_graph = build_topic_graph(clusters, embeddings, topic_assignments)
+        else:
+            logger.warning("topic_clustering_skipped", reason="model unavailable or too few entries")
+
+        await publish_event("analysis_updates", {"job_id": job_id, "status": "processing", "progress": 0.7})
+
+        # Step 4: Build analyzed entries
+        analyzed_entries = []
+        for i, entry in enumerate(entries):
+            topic_id = topic_assignments[i]
+            topic_label = "Uncategorized"
+            for c in clusters:
+                if c.topic_id == topic_id:
+                    topic_label = c.label
+                    break
+
+            analyzed_entries.append(
+                AnalyzedEntry(
+                    id=entry.id or uuid.uuid4().hex[:12],
+                    text=entry.text,
+                    source=entry.source,
+                    timestamp=entry.timestamp,
+                    sentiment=sentiments[i],
+                    language=languages[i],
+                    topic_id=topic_id,
+                    topic_label=topic_label,
+                    metadata=entry.metadata,
+                )
+            )
+
+        # Step 5: Sentiment trends
+        trends = _compute_sentiment_trends(analyzed_entries)
+
+        # Step 6: Data quality
+        data_quality = analyze_data_quality(analyzed_entries)
+
+        # Step 7: Anomaly detection
+        anomalies = []
+        if detect_anomalies and len(sentiments) >= 20:
+            anomalies = run_anomaly_detection(sentiments, topic_assignments)
+            if anomalies:
+                await notify_anomalies(anomalies)
+
+        await publish_event("analysis_updates", {"job_id": job_id, "status": "processing", "progress": 0.9})
+
+        # Build summary
+        sentiment_counts = Counter(s.label.value for s in sentiments)
+        dominant = max(sentiment_counts, key=sentiment_counts.get) if sentiment_counts else "neutral"
+        top_topics = [
+            TopicInfo(
+                topic_id=c.topic_id,
+                label=c.label,
+                keywords=c.keywords,
+                size=c.size,
+            )
+            for c in sorted(clusters, key=lambda c: c.size, reverse=True)[:5]
+            if c.topic_id != -1
+        ]
+
+        summary = AnalysisSummary(
+            total_entries=len(entries),
+            avg_sentiment=round(np.mean([s.score for s in sentiments]), 4),
+            dominant_sentiment=SentimentLabel(dominant),
+            num_topics=len([c for c in clusters if c.topic_id != -1]),
+            top_topics=top_topics,
+            languages_detected=list(set(l.language for l in languages if l.language != "unknown")),
+            date_range=_get_date_range(entries),
+        )
+
+        # Final result
+        result.status = AnalysisStatus.COMPLETED
+        result.completed_at = datetime.utcnow()
+        result.entries = analyzed_entries
+        result.topics = clusters
+        result.sentiment_trends = trends
+        result.topic_graph = topic_graph
+        result.data_quality = data_quality
+        result.anomalies = anomalies
+        result.summary = summary
+        _jobs[job_id] = result
+
+        await publish_event("analysis_updates", {
+            "job_id": job_id,
+            "status": "completed",
+            "progress": 1.0,
+            "total_entries": len(entries),
+        })
+
+        logger.info("analysis_completed", job_id=job_id, entries=len(entries), topics=len(clusters))
+        return result
+
+    except Exception as exc:
+        result.status = AnalysisStatus.FAILED
+        _jobs[job_id] = result
+        await publish_event("analysis_updates", {"job_id": job_id, "status": "failed", "error": str(exc)})
+        logger.error("analysis_failed", job_id=job_id, error=str(exc))
+        raise
+
+
+def _compute_sentiment_trends(entries: list[AnalyzedEntry]) -> list[SentimentTrend]:
+    """Compute sentiment trends over time periods."""
+    dated = [e for e in entries if e.timestamp]
+    if not dated:
+        return [_single_period_trend(entries, "all")]
+
+    dated.sort(key=lambda e: e.timestamp)
+
+    # Determine grouping: daily if span > 7 days, else hourly
+    span = (dated[-1].timestamp - dated[0].timestamp).days
+    if span > 30:
+        fmt = "%Y-%m"
+    elif span > 7:
+        fmt = "%Y-%m-%d"
+    else:
+        fmt = "%Y-%m-%d %H:00"
+
+    groups: dict[str, list[AnalyzedEntry]] = {}
+    for e in dated:
+        key = e.timestamp.strftime(fmt)
+        groups.setdefault(key, []).append(e)
+
+    trends = []
+    for period, group_entries in groups.items():
+        trends.append(_single_period_trend(group_entries, period))
+
+    return trends
+
+
+def _single_period_trend(entries: list[AnalyzedEntry], period: str) -> SentimentTrend:
+    scores = [e.sentiment.score for e in entries]
+    mean = np.mean(scores) if scores else 0.5
+    std = np.std(scores) if scores else 0
+    n = len(scores)
+    se = std / np.sqrt(n) if n > 0 else 0
+
+    return SentimentTrend(
+        period=period,
+        avg_sentiment=round(float(mean), 4),
+        count=n,
+        positive=sum(1 for e in entries if e.sentiment.label == SentimentLabel.POSITIVE),
+        negative=sum(1 for e in entries if e.sentiment.label == SentimentLabel.NEGATIVE),
+        neutral=sum(1 for e in entries if e.sentiment.label == SentimentLabel.NEUTRAL),
+        confidence_lower=round(float(max(0, mean - 1.96 * se)), 4),
+        confidence_upper=round(float(min(1, mean + 1.96 * se)), 4),
+    )
+
+
+def _get_date_range(entries: list[FeedbackEntry]) -> dict[str, str] | None:
+    dated = [e.timestamp for e in entries if e.timestamp]
+    if not dated:
+        return None
+    return {
+        "start": min(dated).isoformat(),
+        "end": max(dated).isoformat(),
+    }
+
+
+def get_job(job_id: str) -> AnalysisResult | None:
+    return _jobs.get(job_id)
+
+
+def get_all_jobs() -> list[AnalysisResult]:
+    return list(_jobs.values())
+
+
+def filter_entries(
+    entries: list[AnalyzedEntry],
+    date_from=None,
+    date_to=None,
+    sentiment_min=None,
+    sentiment_max=None,
+    topics=None,
+    languages=None,
+    sources=None,
+    search_text=None,
+) -> list[AnalyzedEntry]:
+    """Apply filters to analyzed entries."""
+    result = entries
+
+    if date_from:
+        result = [e for e in result if e.timestamp and e.timestamp >= date_from]
+    if date_to:
+        result = [e for e in result if e.timestamp and e.timestamp <= date_to]
+    if sentiment_min is not None:
+        result = [e for e in result if e.sentiment.score >= sentiment_min]
+    if sentiment_max is not None:
+        result = [e for e in result if e.sentiment.score <= sentiment_max]
+    if topics:
+        result = [e for e in result if e.topic_id in topics]
+    if languages:
+        result = [e for e in result if e.language.language in languages]
+    if sources:
+        result = [e for e in result if e.source in sources]
+    if search_text:
+        search_lower = search_text.lower()
+        result = [e for e in result if search_lower in e.text.lower()]
+
+    return result

backend/app/services/anomaly_detection.py

@@ -0,0 +1,133 @@
+"""Anomaly detection: sentiment drift and topic spikes."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+from typing import List, Optional
+
+import numpy as np
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.models.schemas import AnomalyAlert, AnomalyType, SentimentResult
+
+logger = get_logger(__name__)
+
+
+def detect_sentiment_anomalies(
+    sentiments: list[SentimentResult],
+    window: Optional[int] = None,
+    threshold: Optional[float] = None,
+) -> list[AnomalyAlert]:
+    """Detect when sentiment drops below rolling average - threshold * std."""
+    window = window or settings.anomaly_rolling_window
+    threshold = threshold or settings.anomaly_sentiment_threshold
+
+    if len(sentiments) < window:
+        return []
+
+    scores = np.array([s.score for s in sentiments])
+    alerts = []
+
+    for i in range(window, len(scores)):
+        window_slice = scores[i - window : i]
+        mean = np.mean(window_slice)
+        std = np.std(window_slice)
+
+        if std == 0:
+            continue
+
+        z_score = (scores[i] - mean) / std
+
+        if z_score < -threshold:
+            alerts.append(
+                AnomalyAlert(
+                    id=uuid.uuid4().hex[:12],
+                    type=AnomalyType.SENTIMENT_DROP,
+                    severity="high" if z_score < -2 * threshold else "medium",
+                    message=f"Sentiment dropped to {scores[i]:.3f} (rolling avg: {mean:.3f}, z-score: {z_score:.2f})",
+                    detected_at=datetime.utcnow(),
+                    details={
+                        "index": i,
+                        "value": float(scores[i]),
+                        "rolling_mean": float(mean),
+                        "rolling_std": float(std),
+                        "z_score": float(z_score),
+                    },
+                )
+            )
+
+    return alerts
+
+
+def detect_topic_spikes(
+    topic_assignments: list[int],
+    window: Optional[int] = None,
+    threshold: Optional[float] = None,
+) -> list[AnomalyAlert]:
+    """Detect unusual spikes in topic frequency."""
+    window = window or settings.anomaly_rolling_window
+    threshold = threshold or settings.anomaly_topic_spike_threshold
+
+    if len(topic_assignments) < window:
+        return []
+
+    alerts = []
+    unique_topics = set(topic_assignments)
+
+    for topic_id in unique_topics:
+        if topic_id == -1:
+            continue
+
+        occurrences = [1 if t == topic_id else 0 for t in topic_assignments]
+
+        for i in range(window, len(occurrences)):
+            window_slice = occurrences[i - window : i]
+            mean = np.mean(window_slice)
+            std = np.std(window_slice)
+
+            if std == 0:
+                continue
+
+            # Check for spike in last 10% of window
+            recent = occurrences[max(0, i - window // 10) : i]
+            recent_rate = np.mean(recent) if recent else 0
+
+            z_score = (recent_rate - mean) / std if std > 0 else 0
+
+            if z_score > threshold:
+                alerts.append(
+                    AnomalyAlert(
+                        id=uuid.uuid4().hex[:12],
+                        type=AnomalyType.TOPIC_SPIKE,
+                        severity="high" if z_score > 2 * threshold else "medium",
+                        message=f"Topic {topic_id} spike detected (rate: {recent_rate:.3f}, avg: {mean:.3f})",
+                        detected_at=datetime.utcnow(),
+                        details={
+                            "topic_id": topic_id,
+                            "recent_rate": float(recent_rate),
+                            "rolling_mean": float(mean),
+                            "z_score": float(z_score),
+                        },
+                    )
+                )
+                break  # One alert per topic
+
+    return alerts
+
+
+def run_anomaly_detection(
+    sentiments: list[SentimentResult],
+    topic_assignments: list[int],
+    thresholds: Optional[dict] = None,
+) -> list[AnomalyAlert]:
+    """Run all anomaly detection checks."""
+    window = thresholds.get("rolling_window") if thresholds else None
+    sent_thresh = thresholds.get("sentiment_threshold") if thresholds else None
+    topic_thresh = thresholds.get("topic_spike_threshold") if thresholds else None
+
+    alerts = []
+    alerts.extend(detect_sentiment_anomalies(sentiments, window, sent_thresh))
+    alerts.extend(detect_topic_spikes(topic_assignments, window, topic_thresh))
+    return alerts

backend/app/services/data_quality.py

@@ -0,0 +1,62 @@
+"""Data quality analysis: low confidence, mixed language, duplicate detection."""
+
+from __future__ import annotations
+
+from collections import Counter
+from typing import List
+
+from app.models.schemas import AnalyzedEntry, DataQualityReport
+
+
+def analyze_data_quality(entries: list[AnalyzedEntry]) -> DataQualityReport:
+    """Generate data quality report from analyzed entries."""
+    if not entries:
+        return DataQualityReport(
+            total_entries=0,
+            low_confidence_count=0,
+            low_confidence_entries=[],
+            mixed_language_count=0,
+            mixed_language_entries=[],
+            duplicate_count=0,
+            duplicate_entries=[],
+            avg_confidence=0.0,
+            language_distribution={},
+        )
+
+    # Low confidence predictions (< 0.5)
+    low_conf = [e for e in entries if e.sentiment.confidence < 0.5]
+    low_conf_ids = [e.id for e in low_conf[:50]]
+
+    # Mixed language: entries where detected language differs from majority
+    lang_counts = Counter(e.language.language for e in entries)
+    majority_lang = lang_counts.most_common(1)[0][0] if lang_counts else "unknown"
+    mixed_lang = [
+        e for e in entries
+        if e.language.language != majority_lang and e.language.language != "unknown"
+    ]
+    mixed_lang_ids = [e.id for e in mixed_lang[:50]]
+
+    # Duplicate detection via text similarity (exact and near-duplicates)
+    seen_texts: dict[str, str] = {}
+    duplicate_ids = []
+    for e in entries:
+        normalized = e.text.strip().lower()[:200]
+        if normalized in seen_texts:
+            duplicate_ids.append(e.id)
+        else:
+            seen_texts[normalized] = e.id
+
+    # Average confidence
+    avg_conf = sum(e.sentiment.confidence for e in entries) / len(entries)
+
+    return DataQualityReport(
+        total_entries=len(entries),
+        low_confidence_count=len(low_conf),
+        low_confidence_entries=low_conf_ids,
+        mixed_language_count=len(mixed_lang),
+        mixed_language_entries=mixed_lang_ids,
+        duplicate_count=len(duplicate_ids),
+        duplicate_entries=duplicate_ids[:50],
+        avg_confidence=round(avg_conf, 4),
+        language_distribution=dict(lang_counts),
+    )

backend/app/services/export.py

@@ -0,0 +1,131 @@
+"""Export service: CSV, JSON, PDF report generation."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+from typing import List
+
+from app.core.logging import get_logger
+from app.models.schemas import AnalyzedEntry, ExportFormat
+
+logger = get_logger(__name__)
+
+
+def export_csv(entries: list[AnalyzedEntry]) -> bytes:
+    output = io.StringIO()
+    writer = csv.writer(output)
+    writer.writerow([
+        "id", "text", "source", "timestamp", "sentiment_label",
+        "sentiment_score", "confidence", "language", "topic_id", "topic_label",
+    ])
+    for e in entries:
+        writer.writerow([
+            e.id, e.text, e.source or "", e.timestamp or "",
+            e.sentiment.label.value, e.sentiment.score, e.sentiment.confidence,
+            e.language.language, e.topic_id, e.topic_label,
+        ])
+    return output.getvalue().encode("utf-8")
+
+
+def export_json(entries: list[AnalyzedEntry]) -> bytes:
+    data = [
+        {
+            "id": e.id,
+            "text": e.text,
+            "source": e.source,
+            "timestamp": e.timestamp.isoformat() if e.timestamp else None,
+            "sentiment": {
+                "label": e.sentiment.label.value,
+                "score": e.sentiment.score,
+                "confidence": e.sentiment.confidence,
+            },
+            "language": {
+                "language": e.language.language,
+                "confidence": e.language.confidence,
+            },
+            "topic_id": e.topic_id,
+            "topic_label": e.topic_label,
+        }
+        for e in entries
+    ]
+    return json.dumps(data, indent=2, default=str).encode("utf-8")
+
+
+def export_pdf(entries: list[AnalyzedEntry], summary: dict | None = None) -> bytes:
+    """Generate a PDF report using reportlab."""
+    try:
+        from reportlab.lib import colors
+        from reportlab.lib.pagesizes import A4, letter
+        from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+        from reportlab.lib.units import inch
+        from reportlab.platypus import (
+            Paragraph,
+            SimpleDocTemplate,
+            Spacer,
+            Table,
+            TableStyle,
+        )
+    except ImportError:
+        logger.error("reportlab_not_installed")
+        raise ImportError(
+            "PDF export requires reportlab. Install it with: pip install reportlab"
+        )
+
+    buffer = io.BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4)
+    styles = getSampleStyleSheet()
+    elements = []
+
+    # Title
+    title_style = ParagraphStyle("Title", parent=styles["Title"], fontSize=18)
+    elements.append(Paragraph("Topic Analysis Report", title_style))
+    elements.append(Spacer(1, 12))
+
+    # Summary
+    if summary:
+        elements.append(Paragraph("Summary", styles["Heading2"]))
+        for key, val in summary.items():
+            elements.append(Paragraph(f"<b>{key}:</b> {val}", styles["Normal"]))
+        elements.append(Spacer(1, 12))
+
+    # Data table
+    elements.append(Paragraph("Analysis Results", styles["Heading2"]))
+    table_data = [["ID", "Sentiment", "Score", "Language", "Topic"]]
+
+    for e in entries[:500]:  # Limit for PDF
+        table_data.append([
+            e.id[:8],
+            e.sentiment.label.value,
+            f"{e.sentiment.score:.2f}",
+            e.language.language,
+            e.topic_label[:30],
+        ])
+
+    table = Table(table_data, colWidths=[60, 70, 50, 60, 180])
+    table.setStyle(TableStyle([
+        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#1a1a2e")),
+        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+        ("ALIGN", (0, 0), (-1, -1), "LEFT"),
+        ("FONTSIZE", (0, 0), (-1, 0), 10),
+        ("FONTSIZE", (0, 1), (-1, -1), 8),
+        ("BOTTOMPADDING", (0, 0), (-1, 0), 8),
+        ("GRID", (0, 0), (-1, -1), 0.5, colors.grey),
+        ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f5f5f5")]),
+    ]))
+
+    elements.append(table)
+    doc.build(elements)
+    return buffer.getvalue()
+
+
+def export_entries(entries: list[AnalyzedEntry], fmt: ExportFormat, summary: dict | None = None) -> bytes:
+    if fmt == ExportFormat.CSV:
+        return export_csv(entries)
+    elif fmt == ExportFormat.JSON:
+        return export_json(entries)
+    elif fmt == ExportFormat.PDF:
+        return export_pdf(entries, summary)
+    else:
+        raise ValueError(f"Unsupported export format: {fmt}")

backend/app/services/file_processing.py

@@ -0,0 +1,184 @@
+"""File processing service: handles CSV, JSON, Excel, ZIP with chunked uploads."""
+
+from __future__ import annotations
+
+import io
+import json
+import uuid
+import zipfile
+from pathlib import Path
+from typing import List
+
+import pandas as pd
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.models.schemas import FeedbackEntry
+
+logger = get_logger(__name__)
+
+SUPPORTED_EXTENSIONS = {".csv", ".json", ".xlsx", ".xls", ".zip"}
+TEXT_COLUMN_CANDIDATES = [
+    "text", "content", "message", "body", "feedback", "review",
+    "comment", "description", "note", "summary", "title",
+    "Text", "Content", "Message", "Body", "Feedback", "Review",
+]
+TIMESTAMP_COLUMN_CANDIDATES = [
+    "timestamp", "date", "created_at", "created", "time", "datetime",
+    "Timestamp", "Date", "Created", "CreatedAt",
+]
+SOURCE_COLUMN_CANDIDATES = [
+    "source", "channel", "platform", "origin", "category", "type",
+    "Source", "Channel", "Platform",
+]
+
+
+def _find_column(df: pd.DataFrame, candidates: list[str]) -> str | None:
+    for col in candidates:
+        if col in df.columns:
+            return col
+    for col in df.columns:
+        for candidate in candidates:
+            if candidate.lower() in col.lower():
+                return col
+    return None
+
+
+def _df_to_entries(df: pd.DataFrame, source: str | None = None) -> list[FeedbackEntry]:
+    text_col = _find_column(df, TEXT_COLUMN_CANDIDATES)
+    if not text_col:
+        if len(df.columns) == 1:
+            text_col = df.columns[0]
+        else:
+            raise ValueError(
+                f"No text column found. Expected one of: {TEXT_COLUMN_CANDIDATES}. "
+                f"Found columns: {list(df.columns)}"
+            )
+
+    ts_col = _find_column(df, TIMESTAMP_COLUMN_CANDIDATES)
+    src_col = _find_column(df, SOURCE_COLUMN_CANDIDATES)
+
+    entries = []
+    other_cols = [c for c in df.columns if c not in {text_col, ts_col, src_col}]
+
+    for _, row in df.iterrows():
+        text = str(row[text_col]).strip()
+        if not text or text == "nan":
+            continue
+
+        ts = None
+        if ts_col and pd.notna(row.get(ts_col)):
+            try:
+                ts = pd.to_datetime(row[ts_col])
+            except Exception:
+                pass
+
+        src = source
+        if src_col and pd.notna(row.get(src_col)):
+            src = str(row[src_col])
+
+        metadata = {}
+        for col in other_cols:
+            val = row.get(col)
+            if pd.notna(val):
+                metadata[col] = str(val) if not isinstance(val, (int, float, bool)) else val
+
+        entries.append(
+            FeedbackEntry(
+                id=uuid.uuid4().hex[:12],
+                text=text,
+                source=src,
+                timestamp=ts,
+                metadata=metadata if metadata else None,
+            )
+        )
+
+    return entries
+
+
+def parse_csv(content: bytes, source: str | None = None) -> list[FeedbackEntry]:
+    for encoding in ("utf-8", "latin-1", "cp1252"):
+        try:
+            df = pd.read_csv(io.BytesIO(content), encoding=encoding)
+            return _df_to_entries(df, source)
+        except UnicodeDecodeError:
+            continue
+    raise ValueError("Unable to decode CSV file with supported encodings")
+
+
+def parse_json(content: bytes, source: str | None = None) -> list[FeedbackEntry]:
+    data = json.loads(content.decode("utf-8"))
+
+    if isinstance(data, list):
+        if all(isinstance(item, str) for item in data):
+            return [
+                FeedbackEntry(id=uuid.uuid4().hex[:12], text=item, source=source)
+                for item in data
+                if item.strip()
+            ]
+        df = pd.DataFrame(data)
+        return _df_to_entries(df, source)
+    elif isinstance(data, dict):
+        if "data" in data:
+            df = pd.DataFrame(data["data"])
+        elif "entries" in data:
+            df = pd.DataFrame(data["entries"])
+        elif "results" in data:
+            df = pd.DataFrame(data["results"])
+        else:
+            df = pd.DataFrame([data])
+        return _df_to_entries(df, source)
+
+    raise ValueError("Unsupported JSON structure")
+
+
+def parse_excel(content: bytes, source: str | None = None) -> list[FeedbackEntry]:
+    df = pd.read_excel(io.BytesIO(content), engine="openpyxl")
+    return _df_to_entries(df, source)
+
+
+def parse_zip(content: bytes, source: str | None = None) -> list[FeedbackEntry]:
+    all_entries = []
+    with zipfile.ZipFile(io.BytesIO(content)) as zf:
+        for name in zf.namelist():
+            if name.startswith("__MACOSX") or name.startswith("."):
+                continue
+            ext = Path(name).suffix.lower()
+            inner = zf.read(name)
+            file_source = source or Path(name).stem
+            try:
+                if ext == ".csv":
+                    all_entries.extend(parse_csv(inner, file_source))
+                elif ext == ".json":
+                    all_entries.extend(parse_json(inner, file_source))
+                elif ext in (".xlsx", ".xls"):
+                    all_entries.extend(parse_excel(inner, file_source))
+                else:
+                    logger.warning("skipping_unsupported_file_in_zip", filename=name)
+            except Exception as exc:
+                logger.error("error_processing_zip_entry", filename=name, error=str(exc))
+    return all_entries
+
+
+def parse_file(content: bytes, filename: str, source: str | None = None) -> list[FeedbackEntry]:
+    ext = Path(filename).suffix.lower()
+    if ext not in SUPPORTED_EXTENSIONS:
+        raise ValueError(f"Unsupported file format: {ext}. Supported: {SUPPORTED_EXTENSIONS}")
+
+    parsers = {
+        ".csv": parse_csv,
+        ".json": parse_json,
+        ".xlsx": parse_excel,
+        ".xls": parse_excel,
+        ".zip": parse_zip,
+    }
+
+    return parsers[ext](content, source)
+
+
+async def save_upload(content: bytes, filename: str) -> Path:
+    upload_dir = settings.upload_path
+    safe_name = f"{uuid.uuid4().hex[:8]}_{Path(filename).name}"
+    file_path = upload_dir / safe_name
+    file_path.write_bytes(content)
+    return file_path

backend/app/services/language_detection.py

@@ -0,0 +1,58 @@
+"""Language detection with langdetect primary and cld3 fallback."""
+
+from __future__ import annotations
+
+from app.core.logging import get_logger
+from app.models.schemas import LanguageResult
+
+logger = get_logger(__name__)
+
+
+def detect_language(text: str) -> LanguageResult:
+    """Detect language using langdetect with cld3 fallback."""
+    if not text or len(text.strip()) < 3:
+        return LanguageResult(language="unknown", confidence=0.0, method="none")
+
+    # Primary: langdetect
+    try:
+        from langdetect import DetectorFactory, detect_langs
+
+        DetectorFactory.seed = 42
+        results = detect_langs(text)
+        if results:
+            top = results[0]
+            return LanguageResult(
+                language=str(top.lang),
+                confidence=round(top.prob, 4),
+                method="langdetect",
+            )
+    except Exception as exc:
+        logger.debug("langdetect_failed", error=str(exc))
+
+    # Fallback: cld3
+    try:
+        import cld3
+
+        result = cld3.get_language(text)
+        if result and result.is_reliable:
+            return LanguageResult(
+                language=result.language,
+                confidence=round(result.probability, 4),
+                method="cld3",
+            )
+        elif result:
+            return LanguageResult(
+                language=result.language,
+                confidence=round(result.probability, 4),
+                method="cld3",
+            )
+    except ImportError:
+        logger.warning("cld3_not_available", detail="Install pycld3 for fallback detection")
+    except Exception as exc:
+        logger.debug("cld3_failed", error=str(exc))
+
+    return LanguageResult(language="unknown", confidence=0.0, method="none")
+
+
+def detect_languages_batch(texts: list[str]) -> list[LanguageResult]:
+    return [detect_language(t) for t in texts]

backend/app/services/notifications.py

@@ -0,0 +1,92 @@
+"""Notification service for anomaly alerts (email + Slack webhook)."""
+
+from __future__ import annotations
+
+import smtplib
+from email.mime.text import MIMEText
+from typing import List
+
+import httpx
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.models.schemas import AnomalyAlert
+
+logger = get_logger(__name__)
+
+
+async def send_slack_notification(alerts: list[AnomalyAlert]) -> bool:
+    if not settings.slack_webhook_url:
+        logger.debug("slack_webhook_not_configured")
+        return False
+
+    blocks = []
+    for alert in alerts[:10]:
+        emoji = "🔴" if alert.severity == "high" else "🟡"
+        blocks.append(
+            {
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"{emoji} *{alert.type.value}* ({alert.severity})\n{alert.message}",
+                },
+            }
+        )
+
+    payload = {
+        "text": f"🚨 {len(alerts)} anomaly alert(s) detected",
+        "blocks": [
+            {
+                "type": "header",
+                "text": {"type": "plain_text", "text": f"🚨 {len(alerts)} Anomaly Alert(s)"},
+            },
+            *blocks,
+        ],
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=10) as client:
+            resp = await client.post(settings.slack_webhook_url, json=payload)
+            resp.raise_for_status()
+            logger.info("slack_notification_sent", alert_count=len(alerts))
+            return True
+    except Exception as exc:
+        logger.error("slack_notification_failed", error=str(exc))
+        return False
+
+
+async def send_email_notification(alerts: list[AnomalyAlert]) -> bool:
+    if not all([settings.smtp_host, settings.notification_email_from, settings.notification_email_to]):
+        logger.debug("email_notification_not_configured")
+        return False
+
+    body_lines = []
+    for alert in alerts:
+        body_lines.append(f"[{alert.severity.upper()}] {alert.type.value}: {alert.message}")
+        body_lines.append(f"  Detected at: {alert.detected_at.isoformat()}")
+        body_lines.append("")
+
+    msg = MIMEText("\n".join(body_lines))
+    msg["Subject"] = f"Topic Analysis: {len(alerts)} anomaly alert(s)"
+    msg["From"] = settings.notification_email_from
+    msg["To"] = settings.notification_email_to
+
+    try:
+        with smtplib.SMTP(settings.smtp_host, settings.smtp_port) as server:
+            server.starttls()
+            if settings.smtp_user:
+                server.login(settings.smtp_user, settings.smtp_password)
+            server.send_message(msg)
+        logger.info("email_notification_sent", alert_count=len(alerts))
+        return True
+    except Exception as exc:
+        logger.error("email_notification_failed", error=str(exc))
+        return False
+
+
+async def notify_anomalies(alerts: list[AnomalyAlert]) -> None:
+    if not alerts:
+        return
+
+    await send_slack_notification(alerts)
+    await send_email_notification(alerts)

backend/app/services/redis_client.py

@@ -0,0 +1,83 @@
+"""Redis client for caching and SSE broadcast."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, AsyncIterator, Optional
+
+import redis.asyncio as aioredis
+
+from app.core.config import settings
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+_redis: Optional[aioredis.Redis] = None
+
+
+async def get_redis() -> aioredis.Redis:
+    global _redis
+    if _redis is None:
+        _redis = aioredis.from_url(
+            settings.redis_url,
+            decode_responses=True,
+            max_connections=20,
+        )
+    return _redis
+
+
+async def close_redis() -> None:
+    global _redis
+    if _redis:
+        await _redis.aclose()
+        _redis = None
+
+
+async def cache_get(key: str) -> Optional[Any]:
+    try:
+        r = await get_redis()
+        val = await r.get(f"cache:{key}")
+        return json.loads(val) if val else None
+    except Exception as exc:
+        logger.warning("redis_cache_get_failed", key=key, error=str(exc))
+        return None
+
+
+async def cache_set(key: str, value: Any, ttl: int = 300) -> None:
+    try:
+        r = await get_redis()
+        await r.setex(f"cache:{key}", ttl, json.dumps(value, default=str))
+    except Exception as exc:
+        logger.warning("redis_cache_set_failed", key=key, error=str(exc))
+
+
+async def publish_event(channel: str, data: dict) -> None:
+    try:
+        r = await get_redis()
+        await r.publish(channel, json.dumps(data, default=str))
+    except Exception as exc:
+        logger.warning("redis_publish_failed", channel=channel, error=str(exc))
+
+
+async def subscribe_events(channel: str) -> AsyncIterator[dict]:
+    r = await get_redis()
+    pubsub = r.pubsub()
+    await pubsub.subscribe(channel)
+    try:
+        async for message in pubsub.listen():
+            if message["type"] == "message":
+                try:
+                    yield json.loads(message["data"])
+                except json.JSONDecodeError:
+                    continue
+    finally:
+        await pubsub.unsubscribe(channel)
+        await pubsub.aclose()
+
+
+async def check_redis_health() -> bool:
+    try:
+        r = await get_redis()
+        return await r.ping()
+    except Exception:
+        return False

backend/app/services/sentiment.py

@@ -0,0 +1,180 @@
+"""Sentiment analysis using cardiffnlp/twitter-xlm-roberta-base-sentiment."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Optional
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.models.schemas import SentimentLabel, SentimentResult
+
+logger = get_logger(__name__)
+
+_model = None
+_tokenizer = None
+_executor = ThreadPoolExecutor(max_workers=2)
+
+LABEL_MAP = {
+    "negative": SentimentLabel.NEGATIVE,
+    "neutral": SentimentLabel.NEUTRAL,
+    "positive": SentimentLabel.POSITIVE,
+    "LABEL_0": SentimentLabel.NEGATIVE,
+    "LABEL_1": SentimentLabel.NEUTRAL,
+    "LABEL_2": SentimentLabel.POSITIVE,
+}
+
+
+def _load_model():
+    global _model, _tokenizer
+    if _model is not None:
+        return
+
+    try:
+        from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+        model_name = settings.sentiment_model
+        logger.info("loading_sentiment_model", model=model_name)
+        t0 = time.time()
+
+        _tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=settings.model_cache_dir,
+        )
+        logger.info("tokenizer_loaded", model=model_name, elapsed=round(time.time() - t0, 2))
+
+        _model = AutoModelForSequenceClassification.from_pretrained(
+            model_name,
+            cache_dir=settings.model_cache_dir,
+        )
+        _model.eval()
+        label_config = getattr(_model.config, "id2label", {})
+        logger.info(
+            "sentiment_model_loaded",
+            model=model_name,
+            elapsed=round(time.time() - t0, 2),
+            model_labels=str(label_config),
+            num_labels=getattr(_model.config, "num_labels", "unknown"),
+        )
+    except Exception as exc:
+        logger.error("sentiment_model_load_failed", error=str(exc), exc_type=type(exc).__name__)
+        raise
+
+
+def _predict_batch_sync(texts: list[str]) -> list[SentimentResult]:
+    import torch
+    from scipy.special import softmax
+
+    _load_model()
+
+    results = []
+    batch_size = 32
+    t0 = time.time()
+
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i : i + batch_size]
+        truncated = [t[:512] for t in batch]
+
+        inputs = _tokenizer(
+            truncated,
+            padding=True,
+            truncation=True,
+            max_length=512,
+            return_tensors="pt",
+        )
+
+        with torch.no_grad():
+            outputs = _model(**inputs)
+
+        scores = outputs.logits.detach().numpy()
+
+        for j, score_row in enumerate(scores):
+            probs = softmax(score_row)
+            label_idx = int(probs.argmax())
+            # Use model's own id2label mapping (0=negative, 1=neutral, 2=positive)
+            id2label = {0: SentimentLabel.NEGATIVE, 1: SentimentLabel.NEUTRAL, 2: SentimentLabel.POSITIVE}
+            label = id2label.get(label_idx, SentimentLabel.NEUTRAL)
+            confidence = float(probs[label_idx])
+
+            # Sentiment score: -1 (negative) to +1 (positive)
+            sentiment_score = float(probs[2] - probs[0])
+
+            results.append(
+                SentimentResult(
+                    label=label,
+                    score=round(max(0, min(1, (sentiment_score + 1) / 2)), 4),
+                    confidence=round(confidence, 4),
+                )
+            )
+
+        # Log first batch for debugging
+        if i == 0 and len(results) > 0:
+            sample = results[0]
+            logger.info(
+                "sentiment_first_batch_sample",
+                text_preview=truncated[0][:80],
+                label=sample.label.value,
+                score=sample.score,
+                confidence=sample.confidence,
+            )
+
+    elapsed = round(time.time() - t0, 2)
+    logger.info(
+        "sentiment_batch_complete",
+        total_texts=len(texts),
+        elapsed_seconds=elapsed,
+        texts_per_second=round(len(texts) / max(elapsed, 0.001), 1),
+    )
+
+    return results
+
+
+async def analyze_sentiment(texts: list[str]) -> list[SentimentResult]:
+    """Analyze sentiment for a batch of texts asynchronously."""
+    logger.info("analyze_sentiment_called", count=len(texts), using="ml_model")
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(_executor, _predict_batch_sync, texts)
+
+
+def analyze_sentiment_sync(texts: list[str]) -> list[SentimentResult]:
+    """Synchronous sentiment analysis."""
+    logger.info("analyze_sentiment_sync_called", count=len(texts))
+    return _predict_batch_sync(texts)
+
+
+_models_available: Optional[bool] = None
+
+
+def is_model_available() -> bool:
+    """Check if ML model is available. Re-checks on each call until successful."""
+    global _models_available
+    if _models_available is True:
+        return True
+    # Always retry if previously failed — deps may have been installed since last check
+    try:
+        _load_model()
+        _models_available = True
+        logger.info("model_availability_check", available=True)
+    except Exception as exc:
+        _models_available = False
+        logger.warning("model_availability_check", available=False, error=str(exc))
+    return _models_available
+
+
+def get_fallback_sentiment(text: str) -> SentimentResult:
+    """Simple keyword-based fallback when ML model unavailable."""
+    logger.debug("using_fallback_sentiment", text_preview=text[:60])
+    text_lower = text.lower()
+    positive_words = {"good", "great", "excellent", "love", "amazing", "happy", "best", "wonderful", "fantastic"}
+    negative_words = {"bad", "terrible", "awful", "hate", "worst", "horrible", "poor", "disappointing", "angry"}
+
+    pos = sum(1 for w in text_lower.split() if w in positive_words)
+    neg = sum(1 for w in text_lower.split() if w in negative_words)
+
+    if pos > neg:
+        return SentimentResult(label=SentimentLabel.POSITIVE, score=0.7, confidence=0.3)
+    elif neg > pos:
+        return SentimentResult(label=SentimentLabel.NEGATIVE, score=0.3, confidence=0.3)
+    return SentimentResult(label=SentimentLabel.NEUTRAL, score=0.5, confidence=0.3)

backend/app/services/topic_clustering.py

@@ -0,0 +1,220 @@
+"""Topic clustering using BERTopic with HDBSCAN + UMAP."""
+
+from __future__ import annotations
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.models.schemas import TopicCluster, TopicGraph, TopicInfo, TopicLink
+
+logger = get_logger(__name__)
+
+_embedding_model = None
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+def _load_embedding_model():
+    global _embedding_model
+    if _embedding_model is not None:
+        return
+
+    try:
+        from sentence_transformers import SentenceTransformer
+
+        model_name = settings.embedding_model
+        logger.info("loading_embedding_model", model=model_name)
+        _embedding_model = SentenceTransformer(
+            model_name,
+            cache_folder=settings.model_cache_dir,
+        )
+        logger.info("embedding_model_loaded", model=model_name)
+    except Exception as exc:
+        logger.error("embedding_model_load_failed", error=str(exc))
+        raise
+
+
+def _compute_embeddings(texts: list[str]) -> np.ndarray:
+    _load_embedding_model()
+    return _embedding_model.encode(
+        texts,
+        show_progress_bar=False,
+        batch_size=64,
+        normalize_embeddings=True,
+    )
+
+
+def _adaptive_params(n_docs: int) -> dict:
+    """Adapt HDBSCAN/UMAP parameters to data volume."""
+    if n_docs < 20:
+        return {"min_cluster_size": 2, "min_samples": 1, "n_neighbors": 3, "n_components": 2}
+    elif n_docs < 100:
+        return {"min_cluster_size": 3, "min_samples": 2, "n_neighbors": 5, "n_components": 3}
+    elif n_docs < 500:
+        return {"min_cluster_size": 5, "min_samples": 3, "n_neighbors": 10, "n_components": 5}
+    elif n_docs < 2000:
+        return {"min_cluster_size": 10, "min_samples": 5, "n_neighbors": 15, "n_components": 5}
+    else:
+        return {"min_cluster_size": 15, "min_samples": 8, "n_neighbors": 15, "n_components": 10}
+
+
+def _cluster_topics_sync(
+    texts: list[str],
+    embeddings: Optional[np.ndarray] = None,
+    min_cluster_size: Optional[int] = None,
+    min_samples: Optional[int] = None,
+) -> Tuple[list[int], list[TopicCluster], Optional[np.ndarray]]:
+    from bertopic import BERTopic
+    from hdbscan import HDBSCAN
+    from sklearn.feature_extraction.text import CountVectorizer
+    from umap import UMAP
+
+    if embeddings is None:
+        embeddings = _compute_embeddings(texts)
+
+    params = _adaptive_params(len(texts))
+    mcs = min_cluster_size or params["min_cluster_size"]
+    ms = min_samples or params["min_samples"]
+
+    umap_model = UMAP(
+        n_neighbors=params["n_neighbors"],
+        n_components=params["n_components"],
+        min_dist=0.0,
+        metric="cosine",
+        random_state=42,
+    )
+
+    hdbscan_model = HDBSCAN(
+        min_cluster_size=mcs,
+        min_samples=ms,
+        metric="euclidean",
+        prediction_data=True,
+    )
+
+    vectorizer = CountVectorizer(
+        stop_words="english",
+        max_features=10000,
+        ngram_range=(1, 2),
+    )
+
+    topic_model = BERTopic(
+        umap_model=umap_model,
+        hdbscan_model=hdbscan_model,
+        vectorizer_model=vectorizer,
+        calculate_probabilities=True,
+        verbose=False,
+    )
+
+    topics, probs = topic_model.fit_transform(texts, embeddings)
+
+    topic_info = topic_model.get_topic_info()
+    clusters = []
+
+    for _, row in topic_info.iterrows():
+        tid = int(row["Topic"])
+        if tid == -1:
+            label = "Uncategorized"
+            keywords = []
+        else:
+            topic_words = topic_model.get_topic(tid)
+            keywords = [w for w, _ in topic_words[:10]] if topic_words else []
+            label = " | ".join(keywords[:3]) if keywords else f"Topic {tid}"
+
+        indices = [i for i, t in enumerate(topics) if t == tid]
+        rep_docs = [texts[i][:200] for i in indices[:3]]
+
+        clusters.append(
+            TopicCluster(
+                topic_id=tid,
+                label=label,
+                keywords=keywords,
+                size=int(row.get("Count", len(indices))),
+                avg_sentiment=0.0,
+                sentiment_distribution={"positive": 0, "negative": 0, "neutral": 0},
+                languages={},
+                representative_docs=rep_docs,
+            )
+        )
+
+    # Get 2D coordinates for visualization
+    reduced = None
+    if len(texts) > 2:
+        try:
+            umap_2d = UMAP(n_components=2, random_state=42, metric="cosine")
+            reduced = umap_2d.fit_transform(embeddings)
+        except Exception:
+            pass
+
+    return topics, clusters, reduced
+
+
+def build_topic_graph(clusters: list[TopicCluster], embeddings: np.ndarray, topics: list[int]) -> TopicGraph:
+    """Build force-directed graph from topic clusters."""
+    from sklearn.metrics.pairwise import cosine_similarity
+
+    unique_topics = list({c.topic_id for c in clusters if c.topic_id != -1})
+    links = []
+
+    if len(unique_topics) > 1:
+        centroids = []
+        for tid in unique_topics:
+            indices = [i for i, t in enumerate(topics) if t == tid]
+            if indices:
+                centroid = embeddings[indices].mean(axis=0)
+                centroids.append(centroid)
+            else:
+                centroids.append(np.zeros(embeddings.shape[1]))
+
+        sim_matrix = cosine_similarity(np.array(centroids))
+
+        for i, t1 in enumerate(unique_topics):
+            for j, t2 in enumerate(unique_topics):
+                if i < j and sim_matrix[i][j] > 0.1:
+                    links.append(
+                        TopicLink(
+                            source=t1,
+                            target=t2,
+                            weight=round(float(sim_matrix[i][j]), 4),
+                        )
+                    )
+
+    return TopicGraph(nodes=clusters, links=links)
+
+
+async def cluster_topics(
+    texts: list[str],
+    embeddings: Optional[np.ndarray] = None,
+    min_cluster_size: Optional[int] = None,
+    min_samples: Optional[int] = None,
+) -> Tuple[list[int], list[TopicCluster], Optional[np.ndarray]]:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        _executor, _cluster_topics_sync, texts, embeddings, min_cluster_size, min_samples
+    )
+
+
+async def compute_embeddings(texts: list[str]) -> np.ndarray:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(_executor, _compute_embeddings, texts)
+
+
+_embedding_available: Optional[bool] = None
+
+
+def is_embedding_model_available() -> bool:
+    """Check if embedding model is available. Re-checks on each call until successful."""
+    global _embedding_available
+    if _embedding_available is True:
+        return True
+    try:
+        _load_embedding_model()
+        _embedding_available = True
+        logger.info("embedding_model_availability", available=True)
+    except Exception as exc:
+        _embedding_available = False
+        logger.warning("embedding_model_availability", available=False, error=str(exc))
+    return _embedding_available

backend/pyproject.toml

@@ -0,0 +1,12 @@
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "SIM"]
+ignore = ["E501"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+filterwarnings = ["ignore::DeprecationWarning"]

backend/requirements.txt

@@ -0,0 +1,54 @@
+# Backend dependencies — pinned versions
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+pydantic==2.10.4
+pydantic-settings==2.7.1
+python-multipart==0.0.20
+aiofiles==24.1.0
+httpx==0.28.1
+redis[hiredis]==5.2.1
+sse-starlette==2.2.1
+
+# ML / NLP
+torch==2.5.1
+transformers==4.47.1
+sentence-transformers==3.3.1
+bertopic==0.16.4
+hdbscan==0.8.40
+umap-learn==0.5.7
+scikit-learn==1.6.1
+langdetect==1.0.9
+pycld3==0.22
+
+# Data handling
+pandas==2.2.3
+openpyxl==3.1.5
+xlrd==2.0.1
+numpy==1.26.4
+
+# Export
+reportlab==4.2.5
+weasyprint==63.1
+
+# Observability
+opentelemetry-api==1.29.0
+opentelemetry-sdk==1.29.0
+opentelemetry-instrumentation-fastapi==0.50b0
+opentelemetry-exporter-otlp==1.29.0
+prometheus-client==0.21.1
+prometheus-fastapi-instrumentator==7.0.2
+structlog==24.4.0
+
+# Security
+python-jose[cryptography]==3.3.0
+slowapi==0.1.9
+
+# Testing
+pytest==8.3.4
+pytest-asyncio==0.25.0
+pytest-cov==6.0.0
+httpx==0.28.1
+
+# Utilities
+python-dotenv==1.0.1
+tenacity==9.0.0

backend/tests/conftest.py

@@ -0,0 +1,73 @@
+"""Pytest configuration and shared fixtures."""
+
+from __future__ import annotations
+
+import os
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture(autouse=True)
+def mock_env():
+    os.environ["ALLOWED_API_KEYS"] = '["test-key"]'
+    os.environ["REDIS_URL"] = "redis://localhost:6379/0"
+    os.environ["APP_ENV"] = "testing"
+    os.environ["LOG_FORMAT"] = "console"
+    os.environ["CORS_ORIGINS"] = '["http://localhost:3000"]'
+    yield
+
+
+@pytest.fixture
+def api_headers():
+    return {"X-API-Key": "test-key"}
+
+
+@pytest.fixture
+def mock_redis():
+    with patch("app.services.redis_client.get_redis") as mock:
+        redis_mock = AsyncMock()
+        redis_mock.ping.return_value = True
+        redis_mock.get.return_value = None
+        redis_mock.setex.return_value = True
+        redis_mock.publish.return_value = 1
+        mock.return_value = redis_mock
+        yield redis_mock
+
+
+@pytest.fixture
+def mock_sentiment():
+    with patch("app.services.sentiment._load_model"):
+        with patch("app.services.sentiment.is_model_available", return_value=False):
+            yield
+
+
+@pytest.fixture
+def mock_embeddings():
+    with patch("app.services.topic_clustering._load_embedding_model"):
+        with patch("app.services.topic_clustering.is_embedding_model_available", return_value=False):
+            yield
+
+
+@pytest.fixture
+def client(mock_redis, mock_sentiment, mock_embeddings):
+    from app.main import app
+    with TestClient(app) as c:
+        yield c
+
+
+@pytest.fixture
+def sample_csv_content():
+    return b"text,source,timestamp\nGreat product!,survey,2024-01-01\nTerrible service,email,2024-01-02\nOkay experience,chat,2024-01-03\n"
+
+
+@pytest.fixture
+def sample_json_content():
+    import json
+    data = [
+        {"text": "Love this product!", "source": "app", "timestamp": "2024-01-01"},
+        {"text": "Not happy with the service", "source": "email", "timestamp": "2024-01-02"},
+        {"text": "It works fine", "source": "web", "timestamp": "2024-01-03"},
+    ]
+    return json.dumps(data).encode("utf-8")

backend/tests/test_api.py

@@ -0,0 +1,118 @@
+"""Tests for API endpoints."""
+
+from __future__ import annotations
+
+import io
+import json
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+
+class TestHealthEndpoints:
+    def test_health(self, client, api_headers):
+        resp = client.get("/health")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] in ("healthy", "degraded")
+        assert "version" in data
+        assert "uptime_seconds" in data
+
+    def test_liveness(self, client):
+        resp = client.get("/health/live")
+        assert resp.status_code == 200
+        assert resp.json()["status"] == "alive"
+
+
+class TestUploadEndpoints:
+    def test_upload_csv(self, client, api_headers, sample_csv_content):
+        with patch("app.api.analysis.run_analysis", new_callable=AsyncMock) as mock_run:
+            mock_run.return_value = None
+            resp = client.post(
+                "/api/v1/upload",
+                files={"file": ("test.csv", io.BytesIO(sample_csv_content), "text/csv")},
+                headers=api_headers,
+            )
+            assert resp.status_code == 200
+            data = resp.json()
+            assert "job_id" in data
+            assert data["status"] == "pending"
+
+    def test_upload_json(self, client, api_headers, sample_json_content):
+        with patch("app.api.analysis.run_analysis", new_callable=AsyncMock):
+            resp = client.post(
+                "/api/v1/upload",
+                files={"file": ("test.json", io.BytesIO(sample_json_content), "application/json")},
+                headers=api_headers,
+            )
+            assert resp.status_code == 200
+
+    def test_upload_unsupported_format(self, client, api_headers):
+        resp = client.post(
+            "/api/v1/upload",
+            files={"file": ("test.txt", io.BytesIO(b"hello"), "text/plain")},
+            headers=api_headers,
+        )
+        assert resp.status_code == 400
+        assert "Unsupported" in resp.json()["detail"]
+
+    def test_upload_no_api_key(self, client, sample_csv_content):
+        resp = client.post(
+            "/api/v1/upload",
+            files={"file": ("test.csv", io.BytesIO(sample_csv_content), "text/csv")},
+        )
+        assert resp.status_code == 403
+
+    def test_upload_invalid_api_key(self, client, sample_csv_content):
+        resp = client.post(
+            "/api/v1/upload",
+            files={"file": ("test.csv", io.BytesIO(sample_csv_content), "text/csv")},
+            headers={"X-API-Key": "wrong-key"},
+        )
+        assert resp.status_code == 403
+
+    def test_upload_empty_file(self, client, api_headers):
+        resp = client.post(
+            "/api/v1/upload",
+            files={"file": ("test.csv", io.BytesIO(b"text\n"), "text/csv")},
+            headers=api_headers,
+        )
+        assert resp.status_code == 400
+
+
+class TestJobEndpoints:
+    def test_list_jobs(self, client, api_headers):
+        resp = client.get("/api/v1/jobs", headers=api_headers)
+        assert resp.status_code == 200
+        assert isinstance(resp.json(), list)
+
+    def test_get_nonexistent_job(self, client, api_headers):
+        resp = client.get("/api/v1/jobs/nonexistent", headers=api_headers)
+        assert resp.status_code == 404
+
+
+class TestWebhookEndpoints:
+    def test_webhook_invalid_signature(self, client):
+        payload = json.dumps({
+            "event_type": "feedback",
+            "data": [{"text": "test feedback"}],
+        })
+        resp = client.post(
+            "/api/v1/webhooks/ingest",
+            content=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Signature": "v1=invalid",
+                "X-Timestamp": "0",
+            },
+        )
+        assert resp.status_code == 401
+
+    def test_webhook_missing_signature(self, client):
+        payload = json.dumps({"event_type": "feedback", "data": [{"text": "test"}]})
+        resp = client.post(
+            "/api/v1/webhooks/ingest",
+            content=payload,
+            headers={"Content-Type": "application/json"},
+        )
+        assert resp.status_code == 401

backend/tests/test_services.py

@@ -0,0 +1,276 @@
+"""Tests for core services with mocked ML inference."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+
+from app.models.schemas import FeedbackEntry, SentimentLabel, SentimentResult
+
+
+class TestLanguageDetection:
+    def test_detect_english(self):
+        from app.services.language_detection import detect_language
+        result = detect_language("This is a test sentence in English")
+        assert result.language in ("en", "unknown")
+        assert result.confidence >= 0.0
+
+    def test_detect_empty_text(self):
+        from app.services.language_detection import detect_language
+        result = detect_language("")
+        assert result.language == "unknown"
+        assert result.confidence == 0.0
+
+    def test_detect_short_text(self):
+        from app.services.language_detection import detect_language
+        result = detect_language("hi")
+        assert result.language == "unknown"
+
+    def test_batch_detection(self):
+        from app.services.language_detection import detect_languages_batch
+        results = detect_languages_batch(["Hello world", "Bonjour le monde", ""])
+        assert len(results) == 3
+
+
+class TestSentiment:
+    def test_fallback_sentiment_positive(self):
+        from app.services.sentiment import get_fallback_sentiment
+        result = get_fallback_sentiment("This is great and amazing!")
+        assert result.label == SentimentLabel.POSITIVE
+
+    def test_fallback_sentiment_negative(self):
+        from app.services.sentiment import get_fallback_sentiment
+        result = get_fallback_sentiment("This is terrible and awful")
+        assert result.label == SentimentLabel.NEGATIVE
+
+    def test_fallback_sentiment_neutral(self):
+        from app.services.sentiment import get_fallback_sentiment
+        result = get_fallback_sentiment("The weather is cloudy today")
+        assert result.label == SentimentLabel.NEUTRAL
+
+
+class TestFileProcessing:
+    def test_parse_csv(self):
+        from app.services.file_processing import parse_csv
+        content = b"text,source\nHello world,test\nGoodbye world,test\n"
+        entries = parse_csv(content)
+        assert len(entries) == 2
+        assert entries[0].text == "Hello world"
+
+    def test_parse_json_array(self):
+        from app.services.file_processing import parse_json
+        data = [{"text": "entry 1"}, {"text": "entry 2"}]
+        entries = parse_json(json.dumps(data).encode())
+        assert len(entries) == 2
+
+    def test_parse_json_string_array(self):
+        from app.services.file_processing import parse_json
+        data = ["feedback one", "feedback two"]
+        entries = parse_json(json.dumps(data).encode())
+        assert len(entries) == 2
+
+    def test_parse_json_with_wrapper(self):
+        from app.services.file_processing import parse_json
+        data = {"data": [{"text": "entry 1"}]}
+        entries = parse_json(json.dumps(data).encode())
+        assert len(entries) == 1
+
+    def test_parse_csv_missing_text_column(self):
+        from app.services.file_processing import parse_csv
+        content = b"name,age\nJohn,30\n"
+        # Should fall back to first column or raise
+        try:
+            entries = parse_csv(content)
+            assert len(entries) >= 0
+        except ValueError:
+            pass
+
+    def test_unsupported_format(self):
+        from app.services.file_processing import parse_file
+        with pytest.raises(ValueError, match="Unsupported"):
+            parse_file(b"content", "file.txt")
+
+
+class TestAnomalyDetection:
+    def test_no_anomalies_stable(self):
+        from app.services.anomaly_detection import detect_sentiment_anomalies
+        sentiments = [
+            SentimentResult(label=SentimentLabel.NEUTRAL, score=0.5, confidence=0.9)
+            for _ in range(100)
+        ]
+        alerts = detect_sentiment_anomalies(sentiments)
+        assert len(alerts) == 0
+
+    def test_detects_sentiment_drop(self):
+        from app.services.anomaly_detection import detect_sentiment_anomalies
+        sentiments = [
+            SentimentResult(label=SentimentLabel.POSITIVE, score=0.8, confidence=0.9)
+            for _ in range(60)
+        ]
+        sentiments.append(
+            SentimentResult(label=SentimentLabel.NEGATIVE, score=0.1, confidence=0.9)
+        )
+        alerts = detect_sentiment_anomalies(sentiments, window=50, threshold=1.5)
+        assert len(alerts) > 0
+        assert alerts[0].type.value == "sentiment_drop"
+
+    def test_too_few_entries(self):
+        from app.services.anomaly_detection import detect_sentiment_anomalies
+        sentiments = [
+            SentimentResult(label=SentimentLabel.NEUTRAL, score=0.5, confidence=0.9)
+            for _ in range(5)
+        ]
+        alerts = detect_sentiment_anomalies(sentiments, window=50)
+        assert len(alerts) == 0
+
+
+class TestDataQuality:
+    def test_empty_entries(self):
+        from app.services.data_quality import analyze_data_quality
+        report = analyze_data_quality([])
+        assert report.total_entries == 0
+
+    def test_quality_report(self):
+        from app.models.schemas import AnalyzedEntry, LanguageResult
+        from app.services.data_quality import analyze_data_quality
+
+        entries = [
+            AnalyzedEntry(
+                id="1", text="Great product", source="test",
+                sentiment=SentimentResult(label=SentimentLabel.POSITIVE, score=0.9, confidence=0.95),
+                language=LanguageResult(language="en", confidence=0.99, method="langdetect"),
+                topic_id=0, topic_label="Topic 0",
+            ),
+            AnalyzedEntry(
+                id="2", text="Mauvais service", source="test",
+                sentiment=SentimentResult(label=SentimentLabel.NEGATIVE, score=0.2, confidence=0.4),
+                language=LanguageResult(language="fr", confidence=0.85, method="langdetect"),
+                topic_id=1, topic_label="Topic 1",
+            ),
+        ]
+
+        report = analyze_data_quality(entries)
+        assert report.total_entries == 2
+        assert report.low_confidence_count == 1
+        assert report.mixed_language_count == 1
+
+
+class TestExport:
+    def test_export_csv(self):
+        from app.models.schemas import AnalyzedEntry, LanguageResult
+        from app.services.export import export_csv
+
+        entries = [
+            AnalyzedEntry(
+                id="1", text="Test", source="test",
+                sentiment=SentimentResult(label=SentimentLabel.POSITIVE, score=0.9, confidence=0.95),
+                language=LanguageResult(language="en", confidence=0.99, method="langdetect"),
+                topic_id=0, topic_label="Topic 0",
+            ),
+        ]
+        result = export_csv(entries)
+        assert b"id" in result
+        assert b"Test" in result
+
+    def test_export_json(self):
+        from app.models.schemas import AnalyzedEntry, LanguageResult
+        from app.services.export import export_json
+
+        entries = [
+            AnalyzedEntry(
+                id="1", text="Test", source="test",
+                sentiment=SentimentResult(label=SentimentLabel.POSITIVE, score=0.9, confidence=0.95),
+                language=LanguageResult(language="en", confidence=0.99, method="langdetect"),
+                topic_id=0, topic_label="Topic 0",
+            ),
+        ]
+        result = export_json(entries)
+        data = json.loads(result)
+        assert len(data) == 1
+        assert data[0]["text"] == "Test"
+
+
+def _ml_available() -> bool:
+    try:
+        import torch  # noqa: F401
+        import transformers  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+@pytest.mark.skipif(
+    not _ml_available(),
+    reason="ML models not installed — skipping real model tests",
+)
+class TestRealSentimentModel:
+    """Diagnostic tests using the real ML model (not mocked)."""
+
+    def test_model_loads(self):
+        from app.services import sentiment
+        sentiment._load_model()
+        assert sentiment._model is not None
+
+    def test_positive_english(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        results = analyze_sentiment_sync(["I love this product, it is amazing!"])
+        assert len(results) == 1
+        assert results[0].label == SentimentLabel.POSITIVE
+        assert results[0].score > 0.7
+        assert results[0].confidence > 0.5
+
+    def test_negative_english(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        results = analyze_sentiment_sync(["This is terrible, worst experience ever."])
+        assert len(results) == 1
+        assert results[0].label == SentimentLabel.NEGATIVE
+        assert results[0].score < 0.3
+        assert results[0].confidence > 0.5
+
+    def test_neutral_english(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        results = analyze_sentiment_sync(["The order was delivered on Tuesday."])
+        assert len(results) == 1
+        assert results[0].score > 0.3
+        assert results[0].score < 0.7
+
+    def test_multilingual_german(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        results = analyze_sentiment_sync(["Ich bin sehr zufrieden mit dem Service!"])
+        assert results[0].label == SentimentLabel.POSITIVE
+        assert results[0].score > 0.7
+
+    def test_multilingual_spanish_negative(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        results = analyze_sentiment_sync(["Este producto es horrible, no funciona."])
+        assert results[0].label == SentimentLabel.NEGATIVE
+        assert results[0].score < 0.3
+
+    def test_batch_produces_varied_scores(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        texts = [
+            "I love this!",
+            "This is terrible.",
+            "The weather is normal today.",
+            "Best purchase I ever made!",
+            "Worst customer service.",
+        ]
+        results = analyze_sentiment_sync(texts)
+        scores = [r.score for r in results]
+        assert not all(s == 0.5 for s in scores), f"All scores are 0.5: {scores}"
+        assert max(scores) - min(scores) > 0.3, f"Score spread too narrow: {scores}"
+
+    def test_scores_not_all_neutral(self):
+        from app.services.sentiment import analyze_sentiment_sync
+        texts = [
+            "Amazing fantastic wonderful product",
+            "Horrible terrible awful experience",
+            "Normal everyday standard thing",
+        ]
+        results = analyze_sentiment_sync(texts)
+        labels = [r.label for r in results]
+        assert SentimentLabel.NEUTRAL not in labels or len(set(labels)) > 1, \
+            f"All labels are neutral: {labels}"

demo_data/demo_feedback.csv

@@ -0,0 +1,501 @@
+id,text,source,timestamp,rating
+0550d633e0fc,Worst customer service I've ever encountered. Score: 1/5.,app_store,2024-01-01T13:02:00,1
+173ef1403ddb,El servicio al cliente fue increíblemente útil.,support_ticket,2024-01-01T22:34:00,4
+e6b5dff85469,Ich liebe dieses Produkt! Bester Kauf den ich je gemacht habe.,support_ticket,2024-01-01T05:44:00,5
+1a1d71db74d0,カスタマーサービスが非常に親切で助かりました。 スコア: 5/10。,app_store,2024-01-02T19:16:00,5
+e5668ef2ba52,Functional product. Does what it says. Overall rating: 3/5.,survey,2024-01-02T21:14:00,3
+d2ab38a62733,"Standard service, met expectations but didn't exceed them.",twitter,2024-01-02T11:10:00,3
+1e7e92790b1b,Qualité médiocre. Cassé après deux semaines d'utilisation.,email,2024-01-03T19:40:00,1
+1dfe556ae589,"The new feature update is amazing, exactly what I needed.",app_store,2024-01-03T01:14:00,5
+96a99d0e0c89,Excellent value for money. Exceeded my expectations. Overall rating: 5/5.,chat,2024-01-03T08:08:00,5
+7b11f298ec63,Average experience. Delivery was on time.,web_form,2024-01-04T04:32:00,3
+f88afbed6282,Average experience. Delivery was on time.,play_store,2024-01-04T13:38:00,3
+e897b47af36f,Very satisfied with the experience. Highly recommend!,play_store,2024-01-04T00:43:00,5
+a23f0c3ca118,Really impressed with the build quality and design. Score: 5/5.,chat,2024-01-05T09:53:00,4
+dabb18cc10d7,El producto funciona como se describe. Nada especial.,play_store,2024-01-05T15:01:00,3
+c5236a2867ef,Customer service was incredibly helpful and resolved my issue quickly. Overall rating: 5/5.,email,2024-01-06T21:30:00,5
+89d5feeb2dbe,製品は説明通りに動作します。特別なものはありません。,twitter,2024-01-06T12:42:00,3
+bc23021bfd04,Excellent value for money. Exceeded my expectations. Overall rating: 4/5.,app_store,2024-01-06T22:40:00,4
+606cc9cf0904,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,web_form,2024-01-07T08:42:00,3
+8296a3f28b29,Schlechte Qualität. Nach zwei Wochen kaputt gegangen.,support_ticket,2024-01-07T15:51:00,1
+3a739e818bfc,The team went above and beyond to help me. Outstanding!,play_store,2024-01-07T23:03:00,4
+670c149d339a,Das Produkt kam beschädigt an und der Support war nutzlos. Note: 2/10.,web_form,2024-01-08T05:17:00,1
+54e348820065,"Ausgezeichnete Qualität, schneller Versand. Sehr empfehlenswert! Bewertung: 4/5.",web_form,2024-01-08T13:31:00,4
+5327d77f7b35,Product works as described. Nothing special.,web_form,2024-01-08T08:59:00,3
+3393cd2932cc,Qualité médiocre. Cassé après deux semaines d'utilisation.,chat,2024-01-09T15:09:00,1
+b927e7bdc05f,El producto funciona como se describe. Nada especial.,web_form,2024-01-09T01:03:00,3
+888b9177995c,Average experience. Delivery was on time. Overall rating: 3/5.,app_store,2024-01-10T18:15:00,3
+d81bdf9f2357,Mala calidad. Se rompió después de dos semanas.,twitter,2024-01-10T06:42:00,2
+da135c9331b5,"Excellente qualité, livraison rapide. Je recommande vivement !",web_form,2024-01-10T02:00:00,4
+8fd0b472807f,El servicio al cliente fue increíblemente útil.,chat,2024-01-11T02:56:00,5
+92af5b48a7c7,"Ausgezeichnete Qualität, schneller Versand. Sehr empfehlenswert!",app_store,2024-01-11T20:33:00,5
+b2c2c0cc6bbb,Product works as described. Nothing special.,email,2024-01-11T23:35:00,3
+b634861b9043,Le produit est arrivé endommagé et le support était inutile.,web_form,2024-01-12T08:32:00,1
+1d1538f28fd5,Very satisfied with the experience. Highly recommend! Overall rating: 5/5.,support_ticket,2024-01-12T23:28:00,4
+86c5d6ce1088,Ich liebe dieses Produkt! Bester Kauf den ich je gemacht habe.,email,2024-01-12T11:37:00,5
+a0a53f1616dd,Absolutely love this product! Best purchase I've made.,chat,2024-01-13T06:43:00,4
+778d0f82ac8f,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,chat,2024-01-13T23:09:00,3
+fb224973241b,It's okay for the price point. Nothing to complain about.,chat,2024-01-13T13:51:00,3
+4ec684fa590c,Product works as described. Nothing special.,web_form,2024-01-14T07:12:00,3
+e800bce99714,Das Produkt funktioniert wie beschrieben. Nichts Besonderes. Note: 3/10.,survey,2024-01-14T02:49:00,3
+343d312dd42b,Schreckliche Erfahrung. 3 Wochen gewartet ohne Ergebnis.,survey,2024-01-15T03:56:00,2
+36f59b9ff17f,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",play_store,2024-01-15T10:27:00,5
+b0d51f1b0512,J'adore ce produit ! Le meilleur achat que j'ai fait.,chat,2024-01-15T17:43:00,5
+aae9126e971c,"Excellente qualité, livraison rapide. Je recommande vivement !",play_store,2024-01-16T21:54:00,5
+e8dc1b963a6f,Worst customer service I've ever encountered.,support_ticket,2024-01-16T06:26:00,2
+46e6d7b29beb,Der Kundenservice war unglaublich hilfreich. Note: 5/10.,chat,2024-01-16T14:43:00,5
+f7c6833d7219,Not worth the price. Very disappointing quality. Overall rating: 2/5.,app_store,2024-01-17T04:01:00,2
+c531f9434103,Expérience terrible. J'ai attendu 3 semaines pour rien.,chat,2024-01-17T20:36:00,2
+163491235d98,Absolutely love this product! Best purchase I've made.,support_ticket,2024-01-17T03:49:00,4
+a259a173d317,Expérience moyenne. Livraison à temps. Note: 3/5.,twitter,2024-01-18T14:42:00,3
+f400e865ee2f,El producto funciona como se describe. Nada especial.,survey,2024-01-18T15:28:00,3
+a6f2276573c5,El producto funciona como se describe. Nada especial. Calificación: 3/10.,play_store,2024-01-19T10:20:00,3
+51757444a3b3,Le service client était incroyablement utile et efficace. Évaluation: 5/10.,support_ticket,2024-01-19T01:13:00,5
+7d35f60f1579,Expérience moyenne. Livraison à temps.,support_ticket,2024-01-19T11:19:00,3
+bf1be5d15e60,Really impressed with the build quality and design. Would rate 5/10.,app_store,2024-01-20T04:39:00,5
+54063714b971,Really impressed with the build quality and design. Overall rating: 5/5.,twitter,2024-01-20T14:20:00,5
+9a502b79557d,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,app_store,2024-01-20T15:01:00,3
+8a0b4fdaa6c3,Qualité médiocre. Cassé après deux semaines d'utilisation. Note: 1/5.,chat,2024-01-21T19:09:00,2
+140d1db71e91,Experiencia terrible. Esperé 3 semanas sin resultado.,twitter,2024-01-21T08:49:00,1
+9975ccf52bc0,It's okay for the price point. Nothing to complain about. Would rate 3/10.,play_store,2024-01-21T22:12:00,3
+bc467cbf5958,Terrible experience. Waited 3 weeks for delivery that never came.,app_store,2024-01-22T18:50:00,2
+a0336571974a,Not worth the price. Very disappointing quality. Would rate 2/10.,web_form,2024-01-22T11:40:00,2
+c3f31a575d3d,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",web_form,2024-01-22T17:49:00,5
+90c35decddb2,Experiencia promedio. La entrega fue puntual.,web_form,2024-01-23T02:17:00,3
+94e74a08a7bf,"Excellente qualité, livraison rapide. Je recommande vivement ! Note: 5/5.",survey,2024-01-23T11:51:00,5
+dfe9e2a10c94,Expérience moyenne. Livraison à temps.,play_store,2024-01-24T16:12:00,3
+b6fb94eb1892,Très satisfait de l'expérience. Hautement recommandé !,app_store,2024-01-24T15:28:00,4
+c8b70629ff7e,"Excellente qualité, livraison rapide. Je recommande vivement !",twitter,2024-01-24T11:30:00,5
+01f86c46c244,Very satisfied with the experience. Highly recommend! Overall rating: 4/5.,email,2024-01-25T23:34:00,4
+f56d52e51b18,Worst customer service I've ever encountered.,chat,2024-01-25T06:18:00,1
+dfd3e9757cbc,Le service client était incroyablement utile et efficace. Évaluation: 4/10.,app_store,2024-01-25T03:55:00,5
+4d976b6f6a88,Absolutely love this product! Best purchase I've made. Would rate 5/10.,app_store,2024-01-26T15:04:00,4
+bf4450bf2dd7,製品は説明通りに動作します。特別なものはありません。,support_ticket,2024-01-26T03:35:00,3
+a1099b2043a5,The team went above and beyond to help me. Outstanding!,play_store,2024-01-26T19:03:00,4
+6539bc5b1089,"The new feature update is amazing, exactly what I needed. Would rate 4/10.",web_form,2024-01-27T14:44:00,5
+733c121b417e,Très satisfait de l'expérience. Hautement recommandé ! Évaluation: 4/10.,chat,2024-01-27T03:34:00,4
+ac1cca4b7bc4,Average experience. Delivery was on time.,survey,2024-01-28T19:47:00,3
+2060c03dd652,The team went above and beyond to help me. Outstanding!,web_form,2024-01-28T16:34:00,5
+24c8a0d9693f,"Ausgezeichnete Qualität, schneller Versand. Sehr empfehlenswert!",play_store,2024-01-28T08:01:00,4
+f4867eaece55,Expérience moyenne. Livraison à temps.,web_form,2024-01-29T05:30:00,3
+3c19c87c4a10,"Standard service, met expectations but didn't exceed them.",support_ticket,2024-01-29T15:22:00,3
+ed52a1a6d205,Schreckliche Erfahrung. 3 Wochen gewartet ohne Ergebnis.,support_ticket,2024-01-29T15:18:00,2
+4f7928992601,Customer service was incredibly helpful and resolved my issue quickly.,app_store,2024-01-30T12:55:00,5
+f198df0da3a0,Muy satisfecho con la experiencia. ¡Lo recomiendo!,survey,2024-01-30T01:13:00,4
+dc1b9aa72d14,J'adore ce produit ! Le meilleur achat que j'ai fait. Note: 4/5.,play_store,2024-01-30T17:26:00,4
+40946150cc51,"Great quality, fast shipping. Will definitely order again.",survey,2024-01-31T22:18:00,5
+2beccf55e2df,Functional product. Does what it says. Would rate 3/10.,survey,2024-01-31T13:21:00,3
+dd7733e046a7,Schlechte Qualität. Nach zwei Wochen kaputt gegangen.,email,2024-01-31T15:55:00,2
+0843fb436b8d,Muy satisfecho con la experiencia. ¡Lo recomiendo!,chat,2024-02-01T10:55:00,4
+75baf2ad5cf2,J'adore ce produit ! Le meilleur achat que j'ai fait.,support_ticket,2024-02-01T15:45:00,5
+b78ef5099494,Excellent value for money. Exceeded my expectations.,web_form,2024-02-02T14:06:00,4
+6d6a2a6b90f8,Le service client était incroyablement utile et efficace. Note: 5/5.,support_ticket,2024-02-02T10:54:00,5
+5ad7a5d5d629,Product works as described. Nothing special. Would rate 3/10.,play_store,2024-02-02T03:48:00,3
+628981826b8b,製品が破損して届きました。サポートも役に立ちませんでした。,twitter,2024-02-03T01:18:00,2
+82d9e7af73b4,El servicio al cliente fue increíblemente útil. Calificación: 4/10.,chat,2024-02-03T18:09:00,5
+4d93ae3dd21c,Très satisfait de l'expérience. Hautement recommandé !,email,2024-02-03T21:34:00,4
+b676359c603a,製品は説明通りに動作します。特別なものはありません。,survey,2024-02-04T13:44:00,3
+b70f2085da3e,Really impressed with the build quality and design. Score: 5/5.,support_ticket,2024-02-04T09:01:00,5
+5d084a7ecc0b,J'adore ce produit ! Le meilleur achat que j'ai fait.,survey,2024-02-04T23:31:00,4
+32678c956496,Very satisfied with the experience. Highly recommend!,email,2024-02-05T23:49:00,4
+50250461bc18,Excellent value for money. Exceeded my expectations.,survey,2024-02-05T02:58:00,5
+2cfe16ffcac1,Excellent value for money. Exceeded my expectations.,email,2024-02-06T08:53:00,5
+64b362a374c5,It's okay for the price point. Nothing to complain about.,email,2024-02-06T14:04:00,3
+f8cf2040bdc3,Das Produkt funktioniert wie beschrieben. Nichts Besonderes. Bewertung: 3/5.,survey,2024-02-06T14:23:00,3
+c5a4102c0ec3,Absolutely love this product! Best purchase I've made.,chat,2024-02-07T17:20:00,4
+e02fb7dcd6c1,"Standard service, met expectations but didn't exceed them. Would rate 3/10.",chat,2024-02-07T03:06:00,3
+d847a34ad2a9,Très satisfait de l'expérience. Hautement recommandé !,support_ticket,2024-02-07T23:09:00,4
+9c53a13f87f4,ひどい経験でした。3週間待っても届きませんでした。 スコア: 1/10。,twitter,2024-02-08T07:54:00,2
+2fdecc6a7d5e,カスタマーサービスが非常に親切で助かりました。 スコア: 5/10。,chat,2024-02-08T02:42:00,4
+c5ccf0df4480,Average experience. Delivery was on time.,chat,2024-02-08T06:04:00,3
+6c260231024c,Absolutely love this product! Best purchase I've made. Overall rating: 4/5.,app_store,2024-02-09T03:42:00,4
+c542220e734d,"Excellente qualité, livraison rapide. Je recommande vivement ! Évaluation: 5/10.",play_store,2024-02-09T16:07:00,5
+18138fbc57b6,El producto funciona como se describe. Nada especial.,app_store,2024-02-09T07:39:00,3
+075c6e01e4f8,Misleading product description. Nothing like advertised.,play_store,2024-02-10T13:43:00,2
+b9c98afc431e,"Great quality, fast shipping. Will definitely order again. Score: 5/5.",web_form,2024-02-10T16:18:00,5
+20b0b9cb0def,Functional product. Does what it says.,web_form,2024-02-11T06:27:00,3
+ebfecc937650,The team went above and beyond to help me. Outstanding!,twitter,2024-02-11T10:27:00,5
+ac1a64402be9,Expérience moyenne. Livraison à temps. Note: 3/5.,twitter,2024-02-11T23:47:00,3
+9cbd8bbf44e9,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",support_ticket,2024-02-12T13:22:00,4
+9c56d6667025,Poor quality materials. Broke after two weeks of use. Would rate 1/10.,play_store,2024-02-12T17:23:00,1
+5c1d11a5dd01,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,survey,2024-02-12T21:53:00,3
+18ff62b0b951,"Excellente qualité, livraison rapide. Je recommande vivement !",email,2024-02-13T05:55:00,5
+8c7784e2e007,¡Me encanta este producto! La mejor compra que he hecho. Calificación: 4/10.,twitter,2024-02-13T10:10:00,5
+f7115d9153c8,El producto funciona como se describe. Nada especial.,app_store,2024-02-13T04:10:00,3
+d68d8f0b4219,Really impressed with the build quality and design.,play_store,2024-02-14T06:48:00,5
+a49854c53956,Très satisfait de l'expérience. Hautement recommandé !,chat,2024-02-14T09:02:00,5
+c4d95d92ddee,"The new feature update is amazing, exactly what I needed.",twitter,2024-02-15T08:18:00,4
+389f5a9171f1,"Great quality, fast shipping. Will definitely order again.",twitter,2024-02-15T22:14:00,4
+021d3dbea95a,Product works as described. Nothing special.,twitter,2024-02-15T02:55:00,3
+ce92f5aa1131,Terrible experience. Waited 3 weeks for delivery that never came.,web_form,2024-02-16T10:10:00,1
+247d1dd5de5a,The team went above and beyond to help me. Outstanding!,support_ticket,2024-02-16T16:05:00,5
+04dc02158007,J'adore ce produit ! Le meilleur achat que j'ai fait.,chat,2024-02-16T03:33:00,5
+b4413ca52dda,Das Produkt kam beschädigt an und der Support war nutzlos. Bewertung: 2/5.,play_store,2024-02-17T19:09:00,2
+a05c3f9d5e29,Muy satisfecho con la experiencia. ¡Lo recomiendo!,twitter,2024-02-17T18:41:00,5
+b9a9d3e33dc0,Very satisfied with the experience. Highly recommend!,twitter,2024-02-17T18:03:00,4
+fed9888473f7,Excellent value for money. Exceeded my expectations.,play_store,2024-02-18T02:41:00,5
+2ca433075686,素晴らしい品質です。強くお勧めします！,chat,2024-02-18T14:58:00,5
+ac04fd57afc3,カスタマーサービスが非常に親切で助かりました。 評価: 5/5。,web_form,2024-02-18T07:45:00,5
+da14a011772e,カスタマーサービスが非常に親切で助かりました。,app_store,2024-02-19T10:43:00,5
+1cdd5b8c0c40,Muy satisfecho con la experiencia. ¡Lo recomiendo! Puntuación: 4/5.,support_ticket,2024-02-19T11:19:00,4
+8da171ee35f4,Excellent value for money. Exceeded my expectations.,play_store,2024-02-20T21:44:00,5
+5d5d109b06c0,"The new feature update is amazing, exactly what I needed.",chat,2024-02-20T15:12:00,4
+42101be2f892,Ich liebe dieses Produkt! Bester Kauf den ich je gemacht habe.,app_store,2024-02-20T17:53:00,5
+aee5fd8241b0,"Great quality, fast shipping. Will definitely order again.",email,2024-02-21T19:51:00,5
+9720c191019c,Le service client était incroyablement utile et efficace.,web_form,2024-02-21T19:18:00,4
+bf2323afae55,Der Kundenservice war unglaublich hilfreich.,web_form,2024-02-21T06:23:00,5
+dd7462f688fe,Experiencia promedio. La entrega fue puntual.,email,2024-02-22T06:51:00,3
+a14a777be24b,Schlechte Qualität. Nach zwei Wochen kaputt gegangen.,play_store,2024-02-22T22:54:00,1
+d5c68a8124fe,Functional product. Does what it says. Would rate 3/10.,app_store,2024-02-22T11:59:00,3
+063783a4c96d,The team went above and beyond to help me. Outstanding!,app_store,2024-02-23T11:14:00,5
+eb64c0add977,El producto funciona como se describe. Nada especial. Calificación: 3/10.,app_store,2024-02-23T14:39:00,3
+23566e75a4a4,Schlechte Qualität. Nach zwei Wochen kaputt gegangen.,support_ticket,2024-02-24T19:33:00,2
+5f69f5c7df59,Poor quality materials. Broke after two weeks of use.,play_store,2024-02-24T19:29:00,2
+302e4e5e6d4e,Poor quality materials. Broke after two weeks of use.,app_store,2024-02-24T09:27:00,1
+169f965e3cb6,Terrible experience. Waited 3 weeks for delivery that never came.,app_store,2024-02-25T11:04:00,2
+73c9f76a8afa,Excellent value for money. Exceeded my expectations. Would rate 4/10.,play_store,2024-02-25T07:46:00,5
+7e3b9ab6df95,El servicio al cliente fue increíblemente útil.,web_form,2024-02-25T21:29:00,4
+ac10cdfed3bd,Très satisfait de l'expérience. Hautement recommandé ! Note: 4/5.,survey,2024-02-26T10:59:00,5
+aa424db54c37,Le produit est arrivé endommagé et le support était inutile. Note: 2/5.,support_ticket,2024-02-26T11:27:00,2
+66bf64e93e6c,Misleading product description. Nothing like advertised.,play_store,2024-02-26T16:17:00,1
+77ec32f577db,製品が破損して届きました。サポートも役に立ちませんでした。,play_store,2024-02-27T10:06:00,2
+b79aac27202a,El peor servicio al cliente que he experimentado. Puntuación: 2/5.,twitter,2024-02-27T23:55:00,2
+6caaf83f597c,Le produit est arrivé endommagé et le support était inutile. Note: 2/5.,web_form,2024-02-27T04:54:00,1
+526d8f64594d,"Excellente qualité, livraison rapide. Je recommande vivement !",email,2024-02-28T18:02:00,5
+d508b22b559b,Qualité médiocre. Cassé après deux semaines d'utilisation. Évaluation: 2/10.,app_store,2024-02-28T07:07:00,2
+7679a8a35fc1,製品が破損して届きました。サポートも役に立ちませんでした。 スコア: 2/10。,web_form,2024-02-29T22:58:00,1
+bc36cbb607e6,"Great quality, fast shipping. Will definitely order again.",twitter,2024-02-29T14:05:00,5
+ae2f775d7121,Worst customer service I've ever encountered.,email,2024-02-29T22:45:00,1
+2c27fcd963d8,"Great quality, fast shipping. Will definitely order again. Score: 5/5.",web_form,2024-03-01T18:23:00,4
+ab62a3f12541,Really impressed with the build quality and design.,play_store,2024-03-01T13:52:00,4
+e5a8841b80fc,Not worth the price. Very disappointing quality. Score: 1/5.,play_store,2024-03-01T01:53:00,2
+126ea062cbd8,"The new feature update is amazing, exactly what I needed.",survey,2024-03-02T16:57:00,4
+d0d07e36a0b8,カスタマーサービスが非常に親切で助かりました。 評価: 5/5。,twitter,2024-03-02T05:42:00,4
+4aeee428251e,素晴らしい品質です。強くお勧めします！ スコア: 4/10。,survey,2024-03-02T20:34:00,5
+4e085be965de,Schreckliche Erfahrung. 3 Wochen gewartet ohne Ergebnis. Note: 1/10.,web_form,2024-03-03T13:30:00,2
+dc35614e7f48,Not worth the price. Very disappointing quality.,email,2024-03-03T11:25:00,1
+6391048b938d,Worst customer service I've ever encountered.,app_store,2024-03-03T04:06:00,2
+614860c7bc7f,Average experience. Delivery was on time.,twitter,2024-03-04T18:46:00,3
+0ba94e4aae2c,El peor servicio al cliente que he experimentado.,play_store,2024-03-04T15:01:00,2
+2cd21a3b6407,It's okay for the price point. Nothing to complain about. Would rate 3/10.,play_store,2024-03-05T17:00:00,3
+a7771b767fca,Expérience moyenne. Livraison à temps.,chat,2024-03-05T12:03:00,3
+6626e8341b30,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",play_store,2024-03-05T19:43:00,4
+d67316930082,Expérience terrible. J'ai attendu 3 semaines pour rien.,email,2024-03-06T11:48:00,2
+7d73508b37a0,The software crashes constantly. Very frustrating.,web_form,2024-03-06T15:33:00,1
+a6ca4b5e29b7,Experiencia terrible. Esperé 3 semanas sin resultado.,survey,2024-03-06T19:47:00,2
+4a8db1e38a00,Product arrived damaged and customer support was unhelpful.,support_ticket,2024-03-07T21:07:00,1
+a9c8ba0f3417,Poor quality materials. Broke after two weeks of use.,email,2024-03-07T18:30:00,1
+f2affdb0a287,Functional product. Does what it says.,app_store,2024-03-07T03:12:00,3
+5f9d2ff7ec45,Poor quality materials. Broke after two weeks of use.,web_form,2024-03-08T19:58:00,1
+a63a8fffc3ed,El peor servicio al cliente que he experimentado.,web_form,2024-03-08T10:11:00,2
+5399e5852a49,Schlechte Qualität. Nach zwei Wochen kaputt gegangen.,web_form,2024-03-09T22:16:00,1
+bdfb9dacf3d3,Worst customer service I've ever encountered.,web_form,2024-03-09T22:13:00,2
+361d4fb8d236,ひどい���験でした。3週間待っても届きませんでした。 評価: 2/5。,survey,2024-03-09T09:02:00,2
+9acdae4d45dd,Expérience moyenne. Livraison à temps. Note: 3/5.,chat,2024-03-10T19:47:00,3
+2d110d201206,Experiencia terrible. Esperé 3 semanas sin resultado. Puntuación: 2/5.,email,2024-03-10T21:49:00,1
+50076c00863c,ひどい経験でした。3週間待っても届きませんでした。,survey,2024-03-10T06:48:00,2
+2b666b3d4da8,製品が破損して届きました。サポートも役に立ちませんでした。,app_store,2024-03-11T07:34:00,2
+2ece8489ed9b,Product works as described. Nothing special.,web_form,2024-03-11T12:50:00,3
+4b4d830d2a88,Functional product. Does what it says.,web_form,2024-03-11T10:18:00,3
+59b23f162bdd,Average experience. Delivery was on time.,web_form,2024-03-12T10:10:00,3
+ec5cbb02072a,Very satisfied with the experience. Highly recommend!,support_ticket,2024-03-12T06:11:00,5
+01805b045f78,Le service client était incroyablement utile et efficace.,chat,2024-03-13T15:20:00,4
+49386ec69c94,Worst customer service I've ever encountered.,app_store,2024-03-13T09:37:00,2
+656f19b49e10,Terrible experience. Waited 3 weeks for delivery that never came.,survey,2024-03-13T05:25:00,2
+f32ecdbf3bf2,The software crashes constantly. Very frustrating.,twitter,2024-03-14T14:47:00,2
+9b0946c02e90,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,play_store,2024-03-14T21:48:00,3
+22705c465bbf,¡Me encanta este producto! La mejor compra que he hecho.,email,2024-03-14T16:12:00,4
+d936f17c9fe1,Average experience. Delivery was on time.,web_form,2024-03-15T15:05:00,3
+11cd45dc8595,Absolutely love this product! Best purchase I've made.,survey,2024-03-15T21:51:00,4
+a426493fdb35,Poor quality materials. Broke after two weeks of use.,twitter,2024-03-15T01:27:00,1
+54f59417dfaf,"Standard service, met expectations but didn't exceed them. Score: 3/5.",support_ticket,2024-03-16T23:41:00,3
+8807cfab33fa,ひどい経験でした。3週間待っても届きませんでした。,email,2024-03-16T21:42:00,1
+9599268f98b3,El servicio al cliente fue increíblemente útil.,app_store,2024-03-16T07:53:00,4
+b32102273fab,Expérience terrible. J'ai attendu 3 semaines pour rien.,web_form,2024-03-17T07:15:00,1
+db01f92bc44d,製品が破損して届きました。サポートも役に立ちませんでした。 評価: 1/5。,app_store,2024-03-17T02:06:00,1
+5b83380eb993,Misleading product description. Nothing like advertised. Score: 1/5.,twitter,2024-03-18T09:14:00,1
+5f23203cfaf4,Poor quality materials. Broke after two weeks of use.,email,2024-03-18T08:03:00,2
+12101320cd4f,The team went above and beyond to help me. Outstanding!,support_ticket,2024-03-18T10:44:00,5
+81e1839285f2,Misleading product description. Nothing like advertised. Would rate 2/10.,support_ticket,2024-03-19T01:35:00,1
+413b7c7fe009,Not worth the price. Very disappointing quality.,twitter,2024-03-19T14:54:00,1
+1733d7255f2c,Absolutely love this product! Best purchase I've made.,chat,2024-03-19T06:51:00,5
+1cc03469e91f,Product works as described. Nothing special. Overall rating: 3/5.,chat,2024-03-20T22:38:00,3
+545d0bb313e0,Expérience terrible. J'ai attendu 3 semaines pour rien.,survey,2024-03-20T20:22:00,2
+9217d6bb48e9,Terrible experience. Waited 3 weeks for delivery that never came.,twitter,2024-03-20T23:30:00,2
+d5cec0823ea3,Poor quality materials. Broke after two weeks of use.,support_ticket,2024-03-21T00:16:00,1
+5c8873f259db,"The new feature update is amazing, exactly what I needed.",twitter,2024-03-21T20:43:00,5
+73d70d5125b3,Experiencia promedio. La entrega fue puntual.,twitter,2024-03-22T23:50:00,3
+c2e558b70544,Product arrived damaged and customer support was unhelpful.,app_store,2024-03-22T02:52:00,2
+bd26ada51971,¡Me encanta este producto! La mejor compra que he hecho.,web_form,2024-03-22T00:13:00,5
+e564a7c66c93,Qualité médiocre. Cassé après deux semaines d'utilisation.,app_store,2024-03-23T21:31:00,2
+72db904b73ab,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",support_ticket,2024-03-23T09:01:00,4
+f3ec3339069f,El producto funciona como se describe. Nada especial. Calificación: 3/10.,support_ticket,2024-03-23T02:23:00,3
+26eff9c842d7,Product works as described. Nothing special.,app_store,2024-03-24T20:48:00,3
+dc1d6ba29517,El producto llegó dañado y el soporte no ayudó.,play_store,2024-03-24T22:10:00,2
+e7aa1ef201a2,Terrible experience. Waited 3 weeks for delivery that never came.,chat,2024-03-24T01:14:00,2
+d0b623ad00a5,Very satisfied with the experience. Highly recommend!,app_store,2024-03-25T18:42:00,4
+3ae049d27d41,"Great quality, fast shipping. Will definitely order again.",support_ticket,2024-03-25T22:52:00,4
+89d0c21beda2,The team went above and beyond to help me. Outstanding!,support_ticket,2024-03-25T17:21:00,4
+a375efd736b8,製品が破損して届きました。サポートも役に立ちませんでした。 スコア: 1/10。,survey,2024-03-26T10:01:00,2
+d18ac8e50ba5,El peor servicio al cliente que he experimentado.,support_ticket,2024-03-26T21:37:00,2
+e5cedce66157,Le produit fonctionne comme décrit. Rien de spécial. Évaluation: 3/10.,play_store,2024-03-27T11:06:00,3
+e7f1427704dc,Le produit est arrivé endommagé et le support était inutile. Évaluation: 2/10.,play_store,2024-03-27T03:01:00,1
+b74a85c0071c,Expérience terrible. J'ai attendu 3 semaines pour rien. Note: 2/5.,email,2024-03-27T18:33:00,1
+b867a1a840c4,Really impressed with the build quality and design. Would rate 4/10.,play_store,2024-03-28T09:30:00,5
+404c92898c7e,Expérience moyenne. Livraison à temps.,play_store,2024-03-28T06:29:00,3
+be88c46c038e,The team went above and beyond to help me. Outstanding!,twitter,2024-03-28T10:28:00,5
+18b023c1103a,Experiencia terrible. Esperé 3 semanas sin resultado.,twitter,2024-03-29T05:25:00,2
+b6a80b36aae3,Expérience moyenne. Livraison à temps.,play_store,2024-03-29T12:23:00,3
+86a1de9c3563,El peor servicio al cliente que he experimentado.,survey,2024-03-29T06:28:00,2
+887449793d2d,Worst customer service I've ever encountered. Overall rating: 2/5.,web_form,2024-03-30T14:38:00,2
+b693dcc2f5c9,Expérience terrible. J'ai attendu 3 semaines pour rien.,play_store,2024-03-30T17:38:00,1
+fdb477af36db,Product arrived damaged and customer support was unhelpful.,support_ticket,2024-03-31T20:43:00,2
+fa057f188161,"The new feature update is amazing, exactly what I needed.",chat,2024-03-31T16:35:00,5
+f42ca40c1391,Qualité médiocre. Cassé après deux semaines d'utilisation.,app_store,2024-03-31T04:22:00,1
+a34f61b66c0b,製品が破損して届きました。サポートも役に立ちませんでした。 スコア: 2/10。,chat,2024-04-01T14:50:00,2
+aa21d354df9f,Misleading product description. Nothing like advertised.,play_store,2024-04-01T09:02:00,2
+4c24c3d87472,Le produit est arrivé endommagé et le support était inutile.,email,2024-04-01T23:15:00,2
+4e19280e0617,製品が破損して届きました。サポートも役に立ちませんでした。,email,2024-04-02T20:11:00,2
+bc4c02db08a7,El servicio al cliente fue increíblemente útil.,app_store,2024-04-02T13:24:00,4
+f3846d7596d4,Le produit est arrivé endommagé et le support était inutile.,twitter,2024-04-02T17:11:00,1
+fb30ab40f582,Misleading product description. Nothing like advertised.,support_ticket,2024-04-03T20:20:00,1
+3cb99c3724bd,Schlechte Qualität. Nach zwei Wochen kaputt gegangen. Note: 1/10.,survey,2024-04-03T03:15:00,1
+5b4e15892a35,The app is full of bugs. Each update makes it worse.,support_ticket,2024-04-03T04:36:00,1
+cf9df54106d4,Experiencia terrible. Esperé 3 semanas sin resultado.,email,2024-04-04T15:18:00,2
+4fe1947761d1,Experiencia promedio. La entrega fue puntual.,chat,2024-04-04T15:08:00,3
+9d053f2d608c,Misleading product description. Nothing like advertised.,app_store,2024-04-05T02:36:00,2
+81f76698d94e,Very satisfied with the experience. Highly recommend! Score: 5/5.,twitter,2024-04-05T03:17:00,4
+322d70094e7b,製品が破損して届きました。サポートも役に立ちませんでした。,chat,2024-04-05T20:48:00,1
+7f607caac54a,Terrible experience. Waited 3 weeks for delivery that never came.,chat,2024-04-06T03:49:00,2
+dc80149104c9,Experiencia promedio. La entrega fue puntual. Puntuación: 3/5.,survey,2024-04-06T18:22:00,3
+dff2acdd415b,Functional product. Does what it says. Overall rating: 3/5.,email,2024-04-06T08:55:00,3
+ba2038d093d8,"The new feature update is amazing, exactly what I needed.",web_form,2024-04-07T21:25:00,4
+ab8d1e151121,Terrible experience. Waited 3 weeks for delivery that never came.,survey,2024-04-07T02:25:00,2
+f584e5b57190,Product works as described. Nothing special.,web_form,2024-04-07T23:05:00,3
+59b356c778b5,"Standard service, met expectations but didn't exceed them.",twitter,2024-04-08T15:17:00,3
+6a4150e88d00,Misleading product description. Nothing like advertised.,app_store,2024-04-08T21:48:00,1
+c8ea06ef9bce,Das Produkt kam beschädigt an und der Support war nutzlos. Bewertung: 2/5.,email,2024-04-09T13:12:00,1
+91d27827fe8f,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,twitter,2024-04-09T08:05:00,3
+2e25ae4c6ca2,Poor quality materials. Broke after two weeks of use.,play_store,2024-04-09T02:45:00,1
+02f843e52619,Poor quality materials. Broke after two weeks of use.,app_store,2024-04-10T14:00:00,1
+a57a13fde7c1,Average experience. Delivery was on time.,play_store,2024-04-10T07:24:00,3
+5ab13cadd7a8,Das Produkt kam beschädigt an und der Support war nutzlos.,email,2024-04-10T04:41:00,1
+1ad7a81621b8,Not worth the price. Very disappointing quality.,email,2024-04-11T20:47:00,2
+f3a9c5b14225,Product works as described. Nothing special. Would rate 3/10.,email,2024-04-11T10:50:00,3
+fcc9d208c2ca,Worst customer service I've ever encountered.,survey,2024-04-11T22:01:00,1
+580e6abb0f9b,Product arrived damaged and customer support was unhelpful.,support_ticket,2024-04-12T07:31:00,1
+2e7f346e325c,El producto llegó dañado y el soporte no ayudó.,support_ticket,2024-04-12T10:08:00,2
+271077900307,Misleading product description. Nothing like advertised.,play_store,2024-04-12T02:01:00,2
+ff393310ba05,ひどい経験でした。3週間待っても届きませんでした。,support_ticket,2024-04-13T20:45:00,2
+73d3b30c0681,El servicio al cliente fue increíblemente útil. Puntuación: 5/5.,support_ticket,2024-04-13T17:20:00,4
+cb138b5884f9,Le produit est arrivé endommagé et le support était inutile. Évaluation: 2/10.,app_store,2024-04-14T19:38:00,1
+28c3aea3ee75,J'adore ce produit ! Le meilleur achat que j'ai fait. Évaluation: 5/10.,survey,2024-04-14T04:47:00,4
+75df13da99b3,Terrible experience. Waited 3 weeks for delivery that never came. Score: 2/5.,web_form,2024-04-14T11:03:00,2
+10f96758c1a8,Qualité médiocre. Cassé après deux semaines d'utilisation.,app_store,2024-04-15T03:14:00,1
+03c96e160bc7,The app is full of bugs. Each update makes it worse.,app_store,2024-04-15T05:59:00,1
+9a1f59c27bab,Not worth the price. Very disappointing quality. Score: 2/5.,app_store,2024-04-15T21:57:00,1
+a9015f11104c,製品は説明通りに動作します。特別なものはありません。 スコア: 3/10。,web_form,2024-04-16T02:35:00,3
+12741663077a,Mala calidad. Se rompió después de dos semanas.,twitter,2024-04-16T07:29:00,1
+14100a5c8d69,Experiencia terrible. Esperé 3 semanas sin resultado. Calificación: 1/10.,app_store,2024-04-16T20:53:00,1
+69252e0bbf8d,It's okay for the price point. Nothing to complain about. Overall rating: 3/5.,survey,2024-04-17T04:45:00,3
+501c386ac0cc,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,play_store,2024-04-17T11:29:00,3
+76dc7fa1c3b5,Product arrived damaged and customer support was unhelpful.,survey,2024-04-18T04:15:00,2
+2cd63c85fdfb,It's okay for the price point. Nothing to complain about.,play_store,2024-04-18T08:14:00,3
+e09a987e999c,El producto funciona como se describe. Nada especial. Calificación: 3/10.,twitter,2024-04-18T03:34:00,3
+d2db59bbc719,Terrible experience. Waited 3 weeks for delivery that never came. Would rate 1/10.,chat,2024-04-19T04:05:00,2
+b7c8cfe17f76,Expérience terrible. J'ai attendu 3 semaines pour rien.,support_ticket,2024-04-19T05:01:00,1
+0d98b2509fdb,"Great quality, fast shipping. Will definitely order again. Overall rating: 4/5.",play_store,2024-04-19T12:23:00,5
+afb29e245af2,Really impressed with the build quality and design.,twitter,2024-04-20T02:57:00,4
+a92617a33970,Functional product. Does what it says.,web_form,2024-04-20T23:25:00,3
+f01979c7e3dd,Poor quality materials. Broke after two weeks of use.,web_form,2024-04-20T08:17:00,1
+9ee8188eec34,Mala calidad. Se rompió después de dos semanas.,app_store,2024-04-21T17:30:00,2
+4d25d21b5d54,Poor quality materials. Broke after two weeks of use.,app_store,2024-04-21T17:50:00,2
+68cec6a195e0,Expérience terrible. J'ai attendu 3 semaines pour rien.,support_ticket,2024-04-21T16:20:00,1
+62a6a3ef328b,¡Me encanta este producto! La mejor compra que he hecho.,web_form,2024-04-22T08:03:00,5
+9db15c8adf74,Average experience. Delivery was on time. Would rate 3/10.,chat,2024-04-22T05:11:00,3
+ddd461ac0e83,It's okay for the price point. Nothing to complain about.,chat,2024-04-23T18:09:00,3
+a8995de033da,Product arrived damaged and customer support was unhelpful. Overall rating: 1/5.,chat,2024-04-23T10:58:00,2
+cf0609c1cfcb,ひどい経験でした。3週間待っても届きませんでした。 スコア: 1/10。,support_ticket,2024-04-23T02:23:00,2
+0b46244aad20,The software crashes constantly. Very frustrating.,web_form,2024-04-24T13:50:00,1
+973f981ca8ee,Mala calidad. Se rompió después de dos semanas. Calificación: 2/10.,app_store,2024-04-24T04:11:00,1
+a7fcf4aa8eb4,Poor quality materials. Broke after two weeks of use.,web_form,2024-04-24T03:59:00,2
+bc6817c71804,Not worth the price. Very disappointing quality. Overall rating: 2/5.,chat,2024-04-25T08:13:00,2
+eecc004d8f5d,Product arrived damaged and customer support was unhelpful. Would rate 2/10.,support_ticket,2024-04-25T15:56:00,2
+822bd418d317,"The new feature update is amazing, exactly what I needed. Overall rating: 4/5.",play_store,2024-04-25T10:16:00,4
+5a608e492af1,Terrible experience. Waited 3 weeks for delivery that never came.,web_form,2024-04-26T02:21:00,2
+2e2078c0d315,"Standard service, met expectations but didn't exceed them. Overall rating: 3/5.",survey,2024-04-26T13:44:00,3
+9992b76025c3,Misleading product description. Nothing like advertised. Overall rating: 1/5.,web_form,2024-04-27T09:52:00,1
+9b9167666561,Very satisfied with the experience. Highly recommend!,play_store,2024-04-27T15:54:00,5
+cacc430f759e,Schreckliche Erfahrung. 3 Wochen gewartet ohne Ergebnis. Note: 1/10.,web_form,2024-04-27T11:11:00,2
+4d2f814dbaa1,Worst customer service I've ever encountered.,play_store,2024-04-28T04:48:00,2
+f494ca790f4b,Functional product. Does what it says. Score: 3/5.,web_form,2024-04-28T21:55:00,3
+15b6dbaade39,Product arrived damaged and customer support was unhelpful.,email,2024-04-28T16:51:00,2
+d2d7176a11e3,製品が破損して届きました。サポートも役に立ちませんでした。,support_ticket,2024-04-29T04:02:00,2
+a50f1450851b,Das Produkt kam beschädigt an und der Support war nutzlos.,play_store,2024-04-29T08:20:00,2
+e1e0d4d62c30,Mala calidad. Se rompió después de dos semanas.,support_ticket,2024-04-29T00:50:00,2
+40efc5eb438f,¡Me encanta este producto! La mejor compra que he hecho.,play_store,2024-04-30T18:49:00,5
+8242512ea8e0,"Standard service, met expectations but didn't exceed them.",email,2024-04-30T15:02:00,3
+50d18a94c572,Muy satisfecho con la experiencia. ¡Lo recomiendo! Calificación: 5/10.,twitter,2024-04-30T08:57:00,4
+7d217031f852,It's okay for the price point. Nothing to complain about.,play_store,2024-05-01T22:43:00,3
+48b0b5be77e4,Expérience terrible. J'ai attendu 3 semaines pour rien. Évaluation: 1/10.,support_ticket,2024-05-01T06:58:00,2
+ea09df97e12f,El producto funciona como se describe. Nada especial. Puntuación: 3/5.,chat,2024-05-02T06:56:00,3
+1d220675c4a0,Excellent value for money. Exceeded my expectations.,web_form,2024-05-02T08:23:00,5
+c61f1802c573,Misleading product description. Nothing like advertised.,web_form,2024-05-02T05:55:00,2
+5cddb2374982,Schlechte Qualität. Nach zwei Wochen kaputt gegangen.,app_store,2024-05-03T02:18:00,1
+33af4f2edc2b,Experiencia terrible. Esperé 3 semanas sin resultado.,chat,2024-05-03T20:14:00,2
+c9cd5f4f05f3,Schlechte Qualität. Nach zwei Wochen kaputt gegangen. Bewertung: 1/5.,survey,2024-05-03T08:38:00,2
+c52d31c416e8,Das Produkt funktioniert wie beschrieben. Nichts Besonderes. Bewertung: 3/5.,twitter,2024-05-04T00:32:00,3
+2730ef05e7fa,Not worth the price. Very disappointing quality.,survey,2024-05-04T20:20:00,2
+10165b116545,Experiencia terrible. Esperé 3 semanas sin resultado.,twitter,2024-05-04T19:25:00,1
+5fb507265130,ひどい経験でした。3週間待っても届きませんでした。,app_store,2024-05-05T12:24:00,2
+623e6a443af5,Misleading product description. Nothing like advertised.,survey,2024-05-05T21:22:00,1
+c87974c8b9a9,Very satisfied with the experience. Highly recommend!,email,2024-05-05T17:48:00,5
+9d1cbde7fbf4,Very satisfied with the experience. Highly recommend!,survey,2024-05-06T10:23:00,5
+7cf995866844,Functional product. Does what it says.,web_form,2024-05-06T19:04:00,3
+250d6266ed15,It's okay for the price point. Nothing to complain about.,chat,2024-05-07T04:08:00,3
+843d41f74d2d,Das Produkt funktioniert wie beschrieben. Nichts Besonderes. Note: 3/10.,twitter,2024-05-07T20:11:00,3
+0f21bc3ec57b,"Great quality, fast shipping. Will definitely order again.",play_store,2024-05-07T05:31:00,4
+7d02a4ee50ef,Misleading product description. Nothing like advertised.,chat,2024-05-08T01:34:00,1
+170b42fb7a19,Le produit fonctionne comme décrit. Rien de spécial. Évaluation: 3/10.,play_store,2024-05-08T09:08:00,3
+ff7859d5527c,Der Kundenservice war unglaublich hilfreich.,twitter,2024-05-08T14:46:00,5
+061fdaedff5f,カスタマーサービスが非常に親切で助かりました。,support_ticket,2024-05-09T05:58:00,4
+1891677b908a,この製品が大好きです！最高の買い物でした。,email,2024-05-09T18:32:00,4
+0647b75ffb0c,Expérience terrible. J'ai attendu 3 semaines pour rien.,app_store,2024-05-09T08:49:00,1
+150aa21654f3,Terrible experience. Waited 3 weeks for delivery that never came.,survey,2024-05-10T12:07:00,1
+aa3faf994758,J'adore ce produit ! Le meilleur achat que j'ai fait.,survey,2024-05-10T21:06:00,4
+1aa8fb020790,Functional product. Does what it says. Overall rating: 3/5.,survey,2024-05-11T19:12:00,3
+150dcc6d227d,Product arrived damaged and customer support was unhelpful.,web_form,2024-05-11T06:44:00,1
+8d7976b8ccfa,J'adore ce produit ! Le meilleur achat que j'ai fait.,email,2024-05-11T21:31:00,4
+6f858c35935c,Worst customer service I've ever encountered.,survey,2024-05-12T14:18:00,1
+848dcd163944,Absolutely love this product! Best purchase I've made.,twitter,2024-05-12T11:51:00,5
+bd84f35ea401,J'adore ce produit ! Le meilleur achat que j'ai fait. Évaluation: 4/10.,survey,2024-05-12T14:39:00,4
+1f2d3e7e9212,"Standard service, met expectations but didn't exceed them.",support_ticket,2024-05-13T14:17:00,3
+b7b60593dd21,Le produit est arrivé endommagé et le support était inutile. Évaluation: 1/10.,web_form,2024-05-13T18:30:00,2
+e0323f0ac8cb,El producto funciona como se describe. Nada especial.,support_ticket,2024-05-13T15:07:00,3
+fa31b2965135,J'adore ce produit ! Le meilleur achat que j'ai fait.,chat,2024-05-14T21:33:00,5
+7c7942ffd19b,Très satisfait de l'expérience. Hautement recommandé !,support_ticket,2024-05-14T21:41:00,4
+5d5374f10b70,素晴らしい品質です。強くお勧めします！,email,2024-05-15T15:55:00,4
+bace1e085071,Very satisfied with the experience. Highly recommend! Overall rating: 4/5.,web_form,2024-05-15T02:29:00,5
+bcb499bcc7aa,Product works as described. Nothing special.,app_store,2024-05-15T23:41:00,3
+8f2c98d4218a,¡Me encanta este producto! La mejor compra que he hecho.,survey,2024-05-16T19:39:00,4
+c6ffab859e8f,Product works as described. Nothing special.,web_form,2024-05-16T14:21:00,3
+065b8c632edd,Le service client était incroyablement utile et efficace. Note: 5/5.,email,2024-05-16T01:57:00,5
+33be87d724fd,Expérience moyenne. Livraison à temps. Évaluation: 3/10.,chat,2024-05-17T06:29:00,3
+6be00bdb9004,Functional product. Does what it says. Would rate 3/10.,app_store,2024-05-17T00:33:00,3
+8caf1b96d74f,Le produit fonctionne comme décrit. Rien de spécial.,email,2024-05-17T05:46:00,3
+18434f96b724,Mala calidad. Se rompió después de dos semanas.,chat,2024-05-18T12:26:00,2
+1e772c657344,製品は説明通りに動作します。特別なものはありません。,survey,2024-05-18T04:26:00,3
+14e97151cbb4,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",email,2024-05-18T21:08:00,5
+ac485b5e58b9,Experiencia promedio. La entrega fue puntual.,support_ticket,2024-05-19T17:18:00,3
+3590608515ea,Absolutely love this product! Best purchase I've made. Overall rating: 4/5.,survey,2024-05-19T01:44:00,4
+d5dc0e77691e,"The new feature update is amazing, exactly what I needed.",chat,2024-05-20T17:24:00,5
+e62786e9542c,It's okay for the price point. Nothing to complain about.,survey,2024-05-20T01:00:00,3
+f471d8302e37,製品は説明通りに動作します。特別なものはありません。,chat,2024-05-20T17:47:00,3
+36a7285498a9,この製品が大好きです！最高の買い物でした。 評価: 4/5。,survey,2024-05-21T13:17:00,4
+a6216310aa51,Not worth the price. Very disappointing quality.,email,2024-05-21T04:02:00,1
+5780155cd18a,Experiencia promedio. La entrega fue puntual.,twitter,2024-05-21T18:35:00,3
+3771c1095a70,素晴らしい品質です。強くお勧めします！ 評価: 4/5。,chat,2024-05-22T11:14:00,5
+11acc24032cd,Really impressed with the build quality and design.,play_store,2024-05-22T20:00:00,5
+d9cb669457ef,El servicio al cliente fue increíblemente útil.,twitter,2024-05-22T21:56:00,5
+8af6fe2e3d27,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo. Puntuación: 5/5.",chat,2024-05-23T09:57:00,5
+b933d6cd797e,Functional product. Does what it says.,chat,2024-05-23T20:04:00,3
+8bb6d99a448e,"Standard service, met expectations but didn't exceed them.",email,2024-05-24T02:47:00,3
+490f5a8625ac,Terrible experience. Waited 3 weeks for delivery that never came. Would rate 1/10.,web_form,2024-05-24T13:24:00,2
+421bb398eafd,Customer service was incredibly helpful and resolved my issue quickly.,play_store,2024-05-24T20:46:00,4
+5057dad31f32,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",play_store,2024-05-25T09:38:00,5
+121990128874,Ich liebe dieses Produkt! Bester Kauf den ich je gemacht habe.,email,2024-05-25T17:14:00,5
+07f58e9bb0df,It's okay for the price point. Nothing to complain about.,email,2024-05-25T00:35:00,3
+a933cf020589,¡Me encanta este producto! La mejor compra que he hecho.,twitter,2024-05-26T23:47:00,4
+8ad329d31baa,Das Produkt funktioniert wie beschrieben. Nichts Besonderes. Bewertung: 3/5.,app_store,2024-05-26T05:42:00,3
+4dd9b74f599f,Customer service was incredibly helpful and resolved my issue quickly. Overall rating: 5/5.,chat,2024-05-26T21:41:00,4
+c91e26498430,ひどい経験でした。3週間待っても届きませんでした。,survey,2024-05-27T10:39:00,2
+d12cc8db5170,製品は説明通りに動作します。特別なものはありません。 スコア: 3/10。,twitter,2024-05-27T11:08:00,3
+43bbef2f1e6f,Très satisfait de l'expérience. Hautement recommandé !,play_store,2024-05-27T05:41:00,5
+7773474acd14,Product works as described. Nothing special.,app_store,2024-05-28T00:54:00,3
+72702c18d353,Experiencia promedio. La entrega fue puntual.,support_ticket,2024-05-28T04:23:00,3
+d739055b9726,¡Me encanta este producto! La mejor compra que he hecho.,chat,2024-05-29T16:00:00,4
+a82b33b2364b,"Great quality, fast shipping. Will definitely order again.",app_store,2024-05-29T15:22:00,4
+c4627cd85c9c,"The new feature update is amazing, exactly what I needed. Would rate 4/10.",app_store,2024-05-29T14:56:00,4
+1f60c6d4d727,素晴らしい品質です。強くお勧めします！,email,2024-05-30T23:16:00,5
+072c5c1d6a13,J'adore ce produit ! Le meilleur achat que j'ai fait.,chat,2024-05-30T12:58:00,5
+242fc15d6ffa,"Standard service, met expectations but didn't exceed them.",email,2024-05-30T00:32:00,3
+1517985d27df,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo. Puntuación: 4/5.",support_ticket,2024-05-31T21:14:00,5
+df95218b0d2d,"The new feature update is amazing, exactly what I needed.",support_ticket,2024-05-31T20:53:00,4
+9900e7759b57,El servicio al cliente fue increíblemente útil. Puntuación: 4/5.,email,2024-05-31T08:59:00,5
+ae3d97b9d8ad,Expérience moyenne. Livraison à temps.,web_form,2024-06-01T06:28:00,3
+e300c723cbf5,"Great quality, fast shipping. Will definitely order again.",survey,2024-06-01T05:39:00,4
+d1a826c685e2,El producto funciona como se describe. Nada especial. Puntuación: 3/5.,support_ticket,2024-06-02T06:33:00,3
+e1219697ba88,素晴らしい品質です。強くお勧めします！ 評価: 4/5。,app_store,2024-06-02T19:34:00,5
+1e4649494e8a,The team went above and beyond to help me. Outstanding! Score: 5/5.,play_store,2024-06-02T23:58:00,5
+59e70c5d398c,J'adore ce produit ! Le meilleur achat que j'ai fait. Note: 5/5.,app_store,2024-06-03T22:47:00,4
+110dc92921a9,Excellent value for money. Exceeded my expectations.,support_ticket,2024-06-03T03:09:00,5
+1851486dcfa2,It's okay for the price point. Nothing to complain about.,chat,2024-06-03T21:25:00,3
+b4904ca108e9,Muy satisfecho con la experiencia. ¡Lo recomiendo! Puntuación: 5/5.,chat,2024-06-04T21:07:00,5
+d1cabaaad146,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",app_store,2024-06-04T19:44:00,4
+ef3746b1d1a2,Product works as described. Nothing special.,support_ticket,2024-06-04T15:59:00,3
+c24c6da72f48,Absolutely love this product! Best purchase I've made.,survey,2024-06-05T12:39:00,4
+687f221e3dee,Poor quality materials. Broke after two weeks of use.,chat,2024-06-05T16:18:00,1
+3e9ebfbbb39b,Expérience terrible. J'ai attendu 3 semaines pour rien. Évaluation: 1/10.,support_ticket,2024-06-05T12:22:00,1
+72c13722c41e,J'adore ce produit ! Le meilleur achat que j'ai fait.,twitter,2024-06-06T17:18:00,5
+fd59306b1ae1,カスタマーサービスが非常に親切で助かりました。,survey,2024-06-06T18:00:00,4
+a28b9b5eccb8,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",survey,2024-06-07T03:51:00,5
+079f3bc59e94,El producto funciona como se describe. Nada especial.,web_form,2024-06-07T14:43:00,3
+0db2c1f911b2,"The new feature update is amazing, exactly what I needed.",twitter,2024-06-07T07:51:00,5
+7ae50654b135,Very satisfied with the experience. Highly recommend! Overall rating: 4/5.,email,2024-06-08T17:59:00,5
+7a3807dc2020,Der Kundenservice war unglaublich hilfreich. Bewertung: 4/5.,survey,2024-06-08T23:15:00,4
+a5de481553b5,Excellent value for money. Exceeded my expectations. Score: 4/5.,app_store,2024-06-08T21:31:00,4
+57787a914331,Very satisfied with the experience. Highly recommend!,support_ticket,2024-06-09T16:17:00,4
+ee556d2224d9,Très satisfait de l'expérience. Hautement recommandé !,twitter,2024-06-09T01:32:00,5
+b4dc9d0bd3d9,Really impressed with the build quality and design.,chat,2024-06-09T00:00:00,5
+878c2117c4d9,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo. Calificación: 5/10.",twitter,2024-06-10T19:21:00,4
+86dbaa244266,Excellent value for money. Exceeded my expectations.,web_form,2024-06-10T12:17:00,4
+7e548aa56f4d,Le produit fonctionne comme décrit. Rien de spécial.,support_ticket,2024-06-11T07:35:00,3
+8ea6dfdaac77,この製品が大好きです！最高の買い物でした。,support_ticket,2024-06-11T00:11:00,5
+d9475fac1fae,Das Produkt funktioniert wie beschrieben. Nichts Besonderes.,app_store,2024-06-11T09:16:00,3
+a13566e1668a,Worst customer service I've ever encountered.,web_form,2024-06-12T20:06:00,2
+ace332d6c3b8,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",twitter,2024-06-12T13:07:00,4
+a0e253c884d2,It's okay for the price point. Nothing to complain about.,web_form,2024-06-12T15:49:00,3
+ff25c26bfd16,The software crashes constantly. Very frustrating.,twitter,2024-06-13T20:51:00,2
+4e3f46de5fbd,Average experience. Delivery was on time.,survey,2024-06-13T10:20:00,3
+124c46968421,Excellent value for money. Exceeded my expectations.,support_ticket,2024-06-13T16:28:00,4
+e4df0d9d1acb,Average experience. Delivery was on time.,play_store,2024-06-14T23:44:00,3
+5c0ef4a958e7,Really impressed with the build quality and design.,support_ticket,2024-06-14T00:49:00,4
+465dd702ec31,The team went above and beyond to help me. Outstanding!,survey,2024-06-14T07:47:00,5
+996ee71a2644,Ich liebe dieses Produkt! Bester Kauf den ich je gemacht habe. Note: 5/10.,survey,2024-06-15T17:59:00,5
+ebcd9c32c2a6,Le produit fonctionne comme décrit. Rien de spécial.,support_ticket,2024-06-15T14:40:00,3
+a8393d640f33,Customer service was incredibly helpful and resolved my issue quickly.,survey,2024-06-16T11:26:00,4
+2a1ba35ee8cd,El servicio al cliente fue increíblemente útil.,app_store,2024-06-16T15:34:00,5
+a1e0925b2831,"Excellente qualité, livraison rapide. Je recommande vivement !",twitter,2024-06-16T00:35:00,4
+c8cae4d4ad37,Average experience. Delivery was on time. Would rate 3/10.,chat,2024-06-17T02:27:00,3
+1bdaadfd3324,Mala calidad. Se rompió después de dos semanas.,email,2024-06-17T02:11:00,1
+dda4878e3eac,Mala calidad. Se rompió después de dos semanas.,twitter,2024-06-17T15:12:00,1
+10b1d9086a4a,El servicio al cliente fue increíblemente útil.,email,2024-06-18T09:17:00,5
+edc3a7cdd2a3,Really impressed with the build quality and design. Would rate 5/10.,app_store,2024-06-18T14:44:00,5
+c856ddf1fe22,製品は説明通りに動作します。特別なものはありません。 評価: 3/5。,survey,2024-06-18T06:57:00,3
+4f90d45e5c9f,Le service client était incroyablement utile et efficace.,app_store,2024-06-19T14:15:00,4
+f05290b914ca,Poor quality materials. Broke after two weeks of use.,twitter,2024-06-19T21:19:00,1
+0d7a07c75daa,El producto llegó dañado y el soporte no ayudó. Puntuación: 1/5.,play_store,2024-06-20T21:13:00,2
+69152cbaec4f,Very satisfied with the experience. Highly recommend!,chat,2024-06-20T12:50:00,4
+d444eb504b6a,Qualité médiocre. Cassé après deux semaines d'utilisation.,play_store,2024-06-20T11:49:00,1
+9c980249696d,"Excellente qualité, livraison rapide. Je recommande vivement !",app_store,2024-06-21T20:03:00,5
+4f9e1eeea954,Le produit est arrivé endommagé et le support était inutile.,twitter,2024-06-21T10:35:00,1
+c96542d7c843,"Great quality, fast shipping. Will definitely order again. Score: 4/5.",web_form,2024-06-21T09:34:00,4
+027765270430,Really impressed with the build quality and design. Would rate 4/10.,survey,2024-06-22T09:52:00,5
+6121ca8f872b,Muy satisfecho con la experiencia. ¡Lo recomiendo!,twitter,2024-06-22T00:39:00,4
+07c2908a3633,Qualité médiocre. Cassé après deux semaines d'utilisation.,web_form,2024-06-22T06:33:00,2
+e9efb0b27602,¡Me encanta este producto! La mejor compra que he hecho. Puntuación: 4/5.,play_store,2024-06-23T01:12:00,5
+5ea983b64b10,Muy satisfecho con la experiencia. ¡Lo recomiendo!,survey,2024-06-23T16:39:00,4
+162c104bcfa7,J'adore ce produit ! Le meilleur achat que j'ai fait.,web_form,2024-06-23T06:41:00,4
+a8e091488caa,Functional product. Does what it says.,twitter,2024-06-24T13:52:00,3
+ebd01bcb41d3,"Excellente qualité, livraison rapide. Je recommande vivement ! Note: 4/5.",chat,2024-06-24T17:24:00,4
+3ae192e2c3ae,ひどい経験でした。3週間待っても届きませんでした。,twitter,2024-06-25T20:36:00,2
+54729aa27653,Average experience. Delivery was on time.,email,2024-06-25T16:21:00,3
+cac2f6371e53,Experiencia promedio. La entrega fue puntual.,support_ticket,2024-06-25T13:48:00,3
+761cbb4a85d5,Worst customer service I've ever encountered.,support_ticket,2024-06-26T14:28:00,1
+188492cb059b,El producto funciona como se describe. Nada especial.,survey,2024-06-26T09:00:00,3
+5fe5909e7053,It's okay for the price point. Nothing to complain about.,email,2024-06-26T16:35:00,3
+8623f34647f1,Very satisfied with the experience. Highly recommend!,chat,2024-06-27T18:15:00,5
+443844832f8a,"The new feature update is amazing, exactly what I needed.",web_form,2024-06-27T23:20:00,4
+fcfcc04a776a,Le produit fonctionne comme décrit. Rien de spécial.,support_ticket,2024-06-27T09:02:00,3
+1676a3c79ef9,"Standard service, met expectations but didn't exceed them.",chat,2024-06-28T03:55:00,3
+d1d26b71afe9,"Excelente calidad, envío rápido. Definitivamente pediré de nuevo.",chat,2024-06-28T04:20:00,4

demo_data/feedback_feb2024.csv

@@ -0,0 +1,51 @@
+text,source,timestamp,language
+La actualización más reciente mejoró mucho el rendimiento. ¡Genial!,twitter,2024-02-01 06:43:48,Spanish
+Deux semaines sans réponse du support. C'est inadmissible.,support_ticket,2024-02-01 16:28:13,French
+Seit zwei Wochen keine Antwort vom Support. Das ist inakzeptabel.,support_ticket,2024-02-02 08:09:53,German
+サポートに問い合わせて2週間経ちますが、まだ返答がありません。,twitter,2024-02-03 11:01:03,Japanese
+Seit zwei Wochen keine Antwort vom Support. Das ist inakzeptabel.,chat,2024-02-04 16:42:07,German
+Das neue Design ist gewöhnungsbedürftig. Bin noch unentschieden.,twitter,2024-02-05 12:11:30,German
+"Viel zu viele Werbeanzeigen, selbst in der bezahlten Version. Nicht empfehlenswert.",chat,2024-02-05 13:47:30,German
+Das letzte Update hat viele nützliche Funktionen gebracht. Sehr zufrieden!,support_ticket,2024-02-06 04:50:05,German
+El nuevo diseño es diferente. Aún no sé si me gusta más que el anterior.,twitter,2024-02-06 12:17:41,Spanish
+The app crashes every time I try to export a report. Completely unusable.,chat,2024-02-07 02:12:47,English
+The app crashes every time I try to export a report. Completely unusable.,chat,2024-02-07 10:48:49,English
+"Decent product overall. Nothing exceptional, but it gets the job done.",support_ticket,2024-02-08 16:04:05,English
+La qualité du produit est bien en dessous de ce qui était annoncé.,support_ticket,2024-02-08 16:52:03,French
+The app crashes every time I try to export a report. Completely unusable.,chat,2024-02-09 07:41:30,English
+I was charged twice for my subscription and nobody seems to care.,twitter,2024-02-09 13:46:33,English
+Das Produkt war bei Lieferung beschädigt und die Rückgabe ist kompliziert.,chat,2024-02-09 20:24:45,German
+"Viel zu viele Werbeanzeigen, selbst in der bezahlten Version. Nicht empfehlenswert.",twitter,2024-02-09 23:15:43,German
+Der Kundenservice hat mir innerhalb einer Stunde geholfen. Top!,twitter,2024-02-10 00:03:06,German
+最新のアップデート後、バッテリーの消耗が激しくなりました。非常に困っています。,twitter,2024-02-10 02:29:06,Japanese
+"Die App stürzt ständig ab, seit dem letzten Update. Sehr enttäuschend.",support_ticket,2024-02-10 16:09:18,German
+Perdí todos mis datos tras la migración. Estoy muy decepcionado.,twitter,2024-02-10 17:17:27,Spanish
+The new design is different. Not sure if I prefer it over the old one yet.,twitter,2024-02-10 22:38:40,English
+アプリが頻繁にクラッシュして仕事になりません。早急に修正してください。,chat,2024-02-13 00:27:02,Japanese
+Der Kundenservice hat mir innerhalb einer Stunde geholfen. Top!,chat,2024-02-13 12:10:58,German
+Works as expected. Would appreciate more customization options in future updates.,chat,2024-02-13 19:28:58,English
+"Exactly what I was looking for. Simple, elegant, and powerful.",chat,2024-02-14 06:13:41,English
+基本的な機能は問題なく使えますが、もう少し高度な機能が欲しいです。,support_ticket,2024-02-14 06:57:59,Japanese
+La qualité du produit est bien en dessous de ce qui était annoncé.,twitter,2024-02-15 04:01:04,French
+I was charged twice for my subscription and nobody seems to care.,support_ticket,2024-02-16 01:51:51,English
+アプリが頻繁にクラッシュして仕事になりません。早急に修正してください。,support_ticket,2024-02-16 14:11:36,Japanese
+Connection drops constantly. I can't rely on this for my business anymore.,support_ticket,2024-02-16 19:43:50,English
+Deux semaines sans réponse du support. C'est inadmissible.,twitter,2024-02-17 12:05:49,French
+Way too many ads. I'm paying for premium and still seeing banner ads everywhere.,support_ticket,2024-02-17 20:05:25,English
+基本的な機能は問題なく使えますが、もう少し高度な機能が欲しいです。,support_ticket,2024-02-18 07:12:48,Japanese
+Works as expected. Would appreciate more customization options in future updates.,chat,2024-02-18 13:55:16,English
+アプリが頻繁にクラッシュして仕事になりません。早急に修正してください。,support_ticket,2024-02-19 09:27:42,Japanese
+普通の製品です。特に不満はありませんが、特筆すべき点もありません。,chat,2024-02-19 14:28:16,Japanese
+The latest update fixed every issue I had. Developers really listen to feedback.,support_ticket,2024-02-22 11:53:47,English
+Das Produkt war bei Lieferung beschädigt und die Rückgabe ist kompliziert.,twitter,2024-02-22 17:38:10,German
+Best customer experience I've had in years. The support team truly cares.,chat,2024-02-23 14:57:38,English
+"Ganz okay. Nichts Besonderes, aber es erfüllt seinen Zweck.",support_ticket,2024-02-23 20:00:44,German
+Rapport qualité-prix imbattable. Je suis client fidèle depuis un an.,chat,2024-02-24 00:26:22,French
+"Die App stürzt ständig ab, seit dem letzten Update. Sehr enttäuschend.",twitter,2024-02-24 16:42:15,German
+普通の製品です。特に不満はありませんが、特��すべき点もありません。,twitter,2024-02-26 01:23:17,Japanese
+Great value for the price. I've recommended it to all my coworkers.,chat,2024-02-26 01:35:21,English
+El servicio al cliente fue excelente. Resolvieron mi problema en minutos.,chat,2024-02-26 13:04:52,Spanish
+Honestly disappointed. The features advertised on the website don't actually exist.,chat,2024-02-28 05:42:31,English
+I was charged twice for my subscription and nobody seems to care.,twitter,2024-02-28 06:29:34,English
+基本的な機能は問題なく使えますが、もう少し高度な機能が欲しいです。,support_ticket,2024-02-29 07:26:20,Japanese
+"Viel zu viele Werbeanzeigen, selbst in der bezahlten Version. Nicht empfehlenswert.",twitter,2024-02-29 12:45:41,German

demo_data/feedback_jan2024.csv

@@ -0,0 +1,51 @@
+text,source,timestamp,language
+This product has completely changed how I manage my daily workflow. Five stars!,email,2024-01-01 02:24:52,English
+Hervorragende Qualität zum fairen Preis. Kann ich nur weiterempfehlen.,app_store,2024-01-02 19:05:46,German
+La mise à jour a vraiment amélioré les performances. Bravo à l'équipe !,survey,2024-01-02 23:15:52,French
+Shipping was lightning fast and the packaging was eco-friendly. Impressed!,app_store,2024-01-02 23:38:06,English
+Das Produkt war bei Lieferung beschädigt und die Rückgabe ist kompliziert.,email,2024-01-03 01:14:39,German
+"The app works fine for basic tasks, but lacks some advanced features I need.",app_store,2024-01-03 02:08:44,English
+La mise à jour a vraiment amélioré les performances. Bravo à l'équipe !,app_store,2024-01-03 22:10:42,French
+Das neue Design ist gewöhnungsbedürftig. Bin noch unentschieden.,app_store,2024-01-04 23:31:23,German
+"Exactly what I was looking for. Simple, elegant, and powerful.",email,2024-01-05 10:17:47,English
+Muy contento con mi compra. Lo recomiendo sin dudarlo.,survey,2024-01-06 07:19:37,Spanish
+El servicio al cliente fue excelente. Resolvieron mi problema en minutos.,email,2024-01-06 16:30:54,Spanish
+Bin absolut begeistert von der App. Läuft stabil und sieht super aus.,app_store,2024-01-06 22:32:34,German
+Hervorragende Qualität zum fairen Preis. Kann ich nur weiterempfehlen.,survey,2024-01-06 23:03:45,German
+The new design is different. Not sure if I prefer it over the old one yet.,survey,2024-01-07 19:50:30,English
+The search function is broken. It returns completely irrelevant results every time.,survey,2024-01-08 19:03:07,English
+"L'application fonctionne correctement pour les tâches simples, sans plus.",survey,2024-01-10 06:02:34,French
+カスタマーサポートの対応が素晴らしかったです。すぐに問題が解決しました。,survey,2024-01-11 01:15:58,Japanese
+Le nouveau design est différent. Je ne suis pas encore sûr de l'apprécier.,survey,2024-01-11 13:05:25,French
+Great value for the price. I've recommended it to all my coworkers.,app_store,2024-01-12 11:24:52,English
+"Es un producto aceptable. Cumple su función, aunque no destaca en nada.",app_store,2024-01-12 14:11:30,Spanish
+Le service client a été irréprochable. Problème résolu en un clin d'œil.,email,2024-01-12 18:18:53,French
+カスタマーサポートの対応が素晴らしかったです。すぐに問題が解決しました。,app_store,2024-01-12 18:48:49,Japanese
+Le temps de chargement est insupportable. Plusieurs minutes pour ouvrir une page.,email,2024-01-13 08:51:00,French
+"Trop de publicités intrusives. J'ai payé pour la version premium, c'est scandaleux.",survey,2024-01-13 09:09:13,French
+La qualité du produit est bien en dessous de ce qui était annoncé.,email,2024-01-13 17:51:35,French
+J'ai perdu toutes mes données sans aucun avertissement. Très déçu.,survey,2024-01-15 15:40:01,French
+"Die App funktioniert gut für grundlegende Aufgaben, aber es fehlen einige Funktionen.",email,2024-01-16 01:19:00,German
+After the latest update the battery drain is insane. Please fix this ASAP.,survey,2024-01-16 07:10:32,English
+Great value for the price. I've recommended it to all my coworkers.,app_store,2024-01-16 22:31:55,English
+I've been using it for a month now. It's okay but I'm still evaluating alternatives.,email,2024-01-17 08:35:20,English
+The free tier is generous enough for my needs. Might upgrade soon though!,survey,2024-01-17 16:59:56,English
+Really appreciate the attention to detail in the UI. Everything just works.,app_store,2024-01-17 17:11:23,English
+La actualización más reciente mejoró mucho el rendimiento. ¡Genial!,app_store,2024-01-18 02:43:05,Spanish
+Honestly disappointed. The features advertised on the website don't actually exist.,app_store,2024-01-19 13:36:52,English
+Application fantastique ! L'interface est claire et agréable à utiliser.,app_store,2024-01-20 10:49:10,French
+Bin absolut begeistert von der App. Läuft stabil und sieht super aus.,app_store,2024-01-21 05:11:44,German
+Bin absolut begeistert von der App. Läuft stabil und sieht super aus.,survey,2024-01-21 06:10:14,German
+品質が非常に高く、価格以上の価値があります。大満足です。,app_store,2024-01-21 07:38:46,Japanese
+"Me encanta esta aplicación, es muy fácil de usar y funciona de maravilla.",survey,2024-01-23 08:13:00,Spanish
+"Me encanta esta aplicación, es muy fácil de usar y funciona de maravilla.",email,2024-01-23 13:47:26,Spanish
+Bin absolut begeistert von der App. Läuft stabil und sieht super aus.,app_store,2024-01-23 16:32:20,German
+Llevo dos semanas esperando respuesta del soporte técnico. Inaceptable.,survey,2024-01-24 09:55:01,Spanish
+"Exactly what I was looking for. Simple, elegant, and powerful.",app_store,2024-01-24 23:09:45,English
+Best customer experience I've had in years. The support team truly cares.,email,2024-01-26 01:10:05,English
+Application fantastique ! L'interface est claire et agréable à utiliser.,app_store,2024-01-26 11:25:15,French
+Best customer experience I've had in years. The support team truly cares.,email,2024-01-28 05:46:07,English
+Le nouveau design est différent. Je ne suis pas encore sûr de l'apprécier.,email,2024-01-28 21:18:45,French
+"Me encanta esta aplicación, es muy fácil de usar y funciona de maravilla.",app_store,2024-01-29 17:13:00,Spanish
+"Delivery was on time. Product matches the description, nothing more nothing less.",survey,2024-01-30 00:52:14,English
+Le temps de chargement est insupportable. Plusieurs minutes pour ouvrir une page.,email,2024-01-31 03:05:04,French

demo_data/feedback_mar2024.csv

@@ -0,0 +1,51 @@
+text,source,timestamp,language
+"Livraison dans les temps. Le produit correspond à la description, sans surprise.",play_store,2024-03-01 04:23:12,French
+Connection drops constantly. I can't rely on this for my business anymore.,email,2024-03-02 14:45:06,English
+基本的な機能は問題なく使えますが、もう少し高度な機能が欲しいです。,email,2024-03-03 03:03:07,Japanese
+Muy contento con mi compra. Lo recomiendo sin dudarlo.,web_form,2024-03-03 15:41:45,Spanish
+It's a solid tool for beginners. Power users might find it a bit limited.,play_store,2024-03-04 06:31:15,English
+Deux semaines sans réponse du support. C'est inadmissible.,play_store,2024-03-04 08:25:31,French
+Honestly disappointed. The features advertised on the website don't actually exist.,web_form,2024-03-05 06:57:00,English
+Absolutely love this app! The interface is so intuitive and responsive.,email,2024-03-05 17:22:20,English
+アップデートで動作がさらに快適になりました。開発チームに感謝します。,email,2024-03-05 17:49:31,Japanese
+"Livraison dans les temps. Le produit correspond à la description, sans surprise.",email,2024-03-06 02:47:35,French
+アップデートで動作がさらに快適になりました。開発チームに感謝します。,email,2024-03-07 03:33:26,Japanese
+I've been using it for a month now. It's okay but I'm still evaluating alternatives.,web_form,2024-03-07 16:59:24,English
+L'application plante à chaque ouverture depuis la dernière mise à jour.,play_store,2024-03-07 20:52:03,French
+Honestly disappointed. The features advertised on the website don't actually exist.,email,2024-03-09 08:56:28,English
+"Delivery was on time. Product matches the description, nothing more nothing less.",web_form,2024-03-09 10:09:21,English
+Great value for the price. I've recommended it to all my coworkers.,play_store,2024-03-09 15:01:22,English
+"Delivery was on time. Product matches the description, nothing more nothing less.",play_store,2024-03-11 03:33:01,English
+The search function is broken. It returns completely irrelevant results every time.,web_form,2024-03-13 01:18:34,English
+Shipping was lightning fast and the packaging was eco-friendly. Impressed!,play_store,2024-03-13 01:46:14,English
+Das Produkt war bei Lieferung beschädigt und die Rückgabe ist kompliziert.,play_store,2024-03-14 12:04:02,German
+Producto de gran calidad. Superó todas mis expectativas.,email,2024-03-15 01:35:10,Spanish
+J'ai perdu toutes mes données sans aucun avertissement. Très déçu.,web_form,2024-03-16 03:14:33,French
+Le temps de chargement est insupportable. Plusieurs minutes pour ouvrir une page.,email,2024-03-16 05:10:15,French
+"L'application fonctionne correctement pour les tâches simples, sans plus.",play_store,2024-03-17 12:21:44,French
+This product has completely changed how I manage my daily workflow. Five stars!,email,2024-03-17 13:23:16,English
+It's a solid tool for beginners. Power users might find it a bit limited.,play_store,2024-03-17 16:26:09,English
+The onboarding process was seamless. I was up and running in minutes.,play_store,2024-03-17 19:42:09,English
+"Exactly what I was looking for. Simple, elegant, and powerful.",web_form,2024-03-18 11:35:35,English
+Le nouveau design est différent. Je ne suis pas encore sûr de l'apprécier.,email,2024-03-19 00:40:37,French
+The search function is broken. It returns completely irrelevant results every time.,email,2024-03-19 22:05:11,English
+L'application plante à chaque ouverture depuis la dernière mise à jour.,email,2024-03-21 01:46:19,French
+新しいデザインは慣れが必要です。前の方が良かったかもしれません。,email,2024-03-21 13:16:17,Japanese
+"Delivery was on time. Product matches the description, nothing more nothing less.",email,2024-03-21 23:56:46,English
+"Es un producto aceptable. Cumple su función, aunque no destaca en nada.",web_form,2024-03-22 14:42:41,Spanish
+The free tier is generous enough for my needs. Might upgrade soon though!,web_form,2024-03-22 21:34:32,English
+"Lost all my data after the migration. No warning, no backup option. Furious.",email,2024-03-23 06:27:27,English
+The new design is different. Not sure if I prefer it over the old one yet.,web_form,2024-03-23 08:38:07,English
+"Trop de publicités intrusives. J'ai payé pour la version premium, c'est scandaleux.",email,2024-03-24 12:04:27,French
+The free tier is generous enough for my needs. Might upgrade soon though!,play_store,2024-03-24 18:34:19,English
+Shipping was lightning fast and the packaging was eco-friendly. Impressed!,play_store,2024-03-25 17:35:13,English
+The UI redesign is awful. Everything I need is now buried under three menus.,email,2024-03-25 23:18:45,English
+アップデートで動作がさらに快適になりました。開発チームに感謝します。,play_store,2024-03-26 21:10:24,Japanese
+Absolutely love this app! The interface is so intuitive and responsive.,play_store,2024-03-27 09:06:31,English
+Très satisfait de la qualité du produit. Je le recommande vivement.,play_store,2024-03-27 09:40:27,French
+Le temps de chargement est insupportable. Plusieurs minutes pour ouvrir une page.,web_form,2024-03-27 13:24:30,French
+The onboarding process was seamless. I was up and running in minutes.,web_form,2024-03-27 20:56:13,English
+Customer support responded within an hour and solved my issue on the first try.,email,2024-03-28 06:47:58,English
+Bin absolut begeistert von der App. Läuft stabil und sieht super aus.,play_store,2024-03-28 07:56:00,German
+このアプリは本当に使いやすくて、毎日愛用しています。おすすめです！,web_form,2024-03-30 10:30:39,Japanese
+Works as expected. Would appreciate more customization options in future updates.,play_store,2024-03-31 21:29:36,English

frontend/Dockerfile

@@ -0,0 +1,19 @@
+FROM node:20-alpine AS build
+
+WORKDIR /app
+
+COPY package.json package-lock.json* ./
+RUN npm ci
+
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+
+COPY --from=build /app/dist /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD wget -qO- http://localhost:80/ || exit 1

frontend/eslint.config.js

@@ -0,0 +1,26 @@
+import js from '@eslint/js';
+import globals from 'globals';
+import reactHooks from 'eslint-plugin-react-hooks';
+import reactRefresh from 'eslint-plugin-react-refresh';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  { ignores: ['dist', 'coverage'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': ['warn', { allowConstantExport: true }],
+      '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    },
+  }
+);

frontend/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Topic Analysis Dashboard</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/nginx.conf

@@ -0,0 +1,18 @@
+server {
+    listen 80;
+    server_name localhost;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    location /assets/ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    gzip on;
+    gzip_types text/plain text/css application/json application/javascript text/xml;
+}

frontend/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "topic-analysis-frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "format": "prettier --write 'src/**/*.{ts,tsx,css}'",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "react-router-dom": "7.1.1",
+    "recharts": "2.15.0",
+    "d3-force": "3.0.0",
+    "d3-selection": "3.0.0",
+    "d3-zoom": "3.0.0",
+    "lucide-react": "0.468.0",
+    "clsx": "2.1.1",
+    "date-fns": "4.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.17.0",
+    "@testing-library/jest-dom": "6.6.3",
+    "@testing-library/react": "16.1.0",
+    "@testing-library/user-event": "14.5.2",
+    "@types/d3-force": "3.0.10",
+    "@types/d3-selection": "3.0.11",
+    "@types/d3-zoom": "3.0.8",
+    "@types/react": "18.3.18",
+    "@types/react-dom": "18.3.5",
+    "@vitejs/plugin-react": "4.3.4",
+    "eslint": "9.17.0",
+    "eslint-plugin-react-hooks": "5.1.0",
+    "eslint-plugin-react-refresh": "0.4.16",
+    "globals": "15.14.0",
+    "jsdom": "25.0.1",
+    "msw": "2.7.0",
+    "prettier": "3.4.2",
+    "typescript": "5.7.2",
+    "typescript-eslint": "8.18.2",
+    "vite": "6.0.5",
+    "vitest": "2.1.8",
+    "@vitest/coverage-v8": "2.1.8"
+  }
+}

frontend/src/App.tsx

@@ -0,0 +1,33 @@
+import { BrowserRouter, Routes, Route } from 'react-router-dom';
+import { Sidebar } from './components/layout/Sidebar';
+import { DashboardPage } from './pages/DashboardPage';
+import { UploadPage } from './pages/UploadPage';
+import { DataQualityPage } from './pages/DataQualityPage';
+import { ComparePage } from './pages/ComparePage';
+import { SettingsPage } from './pages/SettingsPage';
+import { AnalysisProvider } from './hooks/useAnalysis';
+import { useTheme } from './hooks/useTheme';
+import './styles/globals.css';
+
+export default function App() {
+  const { theme, toggleTheme } = useTheme();
+
+  return (
+    <BrowserRouter>
+      <AnalysisProvider>
+        <div className="app-layout">
+          <Sidebar theme={theme} onToggleTheme={toggleTheme} />
+          <main className="main-content">
+            <Routes>
+              <Route path="/" element={<DashboardPage />} />
+              <Route path="/upload" element={<UploadPage />} />
+              <Route path="/quality" element={<DataQualityPage />} />
+              <Route path="/compare" element={<ComparePage />} />
+              <Route path="/settings" element={<SettingsPage />} />
+            </Routes>
+          </main>
+        </div>
+      </AnalysisProvider>
+    </BrowserRouter>
+  );
+}

frontend/src/__mocks__/handlers.ts

@@ -0,0 +1,185 @@
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import type { AnalysisResult, JobStatus } from '../types';
+
+const mockJobStatus: JobStatus = {
+  job_id: 'test-job-1',
+  status: 'completed',
+  progress: 1.0,
+  message: 'Analysis complete',
+  created_at: '2024-01-01T00:00:00Z',
+  completed_at: '2024-01-01T00:05:00Z',
+};
+
+const mockAnalysisResult: AnalysisResult = {
+  job_id: 'test-job-1',
+  status: 'completed',
+  created_at: '2024-01-01T00:00:00Z',
+  completed_at: '2024-01-01T00:05:00Z',
+  total_entries: 3,
+  entries: [
+    {
+      id: '1',
+      text: 'Great product!',
+      source: 'survey',
+      timestamp: '2024-01-01T00:00:00Z',
+      sentiment: { label: 'positive', score: 0.9, confidence: 0.95 },
+      language: { language: 'en', confidence: 0.99, method: 'langdetect' },
+      topic_id: 0,
+      topic_label: 'Product Quality',
+    },
+    {
+      id: '2',
+      text: 'Terrible service',
+      source: 'email',
+      timestamp: '2024-01-02T00:00:00Z',
+      sentiment: { label: 'negative', score: 0.2, confidence: 0.88 },
+      language: { language: 'en', confidence: 0.98, method: 'langdetect' },
+      topic_id: 1,
+      topic_label: 'Customer Service',
+    },
+    {
+      id: '3',
+      text: 'It works fine',
+      source: 'chat',
+      timestamp: '2024-01-03T00:00:00Z',
+      sentiment: { label: 'neutral', score: 0.5, confidence: 0.7 },
+      language: { language: 'en', confidence: 0.95, method: 'langdetect' },
+      topic_id: 0,
+      topic_label: 'Product Quality',
+    },
+  ],
+  topics: [
+    {
+      topic_id: 0,
+      label: 'Product Quality',
+      keywords: ['product', 'quality', 'great'],
+      size: 2,
+      avg_sentiment: 0.7,
+      sentiment_distribution: { positive: 1, neutral: 1, negative: 0 },
+      languages: { en: 2 },
+      representative_docs: ['Great product!', 'It works fine'],
+    },
+    {
+      topic_id: 1,
+      label: 'Customer Service',
+      keywords: ['service', 'support', 'help'],
+      size: 1,
+      avg_sentiment: 0.2,
+      sentiment_distribution: { positive: 0, neutral: 0, negative: 1 },
+      languages: { en: 1 },
+      representative_docs: ['Terrible service'],
+    },
+  ],
+  sentiment_trends: [
+    {
+      period: '2024-01-01',
+      avg_sentiment: 0.9,
+      count: 1,
+      positive: 1,
+      negative: 0,
+      neutral: 0,
+      confidence_lower: 0.8,
+      confidence_upper: 1.0,
+    },
+    {
+      period: '2024-01-02',
+      avg_sentiment: 0.2,
+      count: 1,
+      positive: 0,
+      negative: 1,
+      neutral: 0,
+      confidence_lower: 0.1,
+      confidence_upper: 0.3,
+    },
+  ],
+  topic_graph: {
+    nodes: [
+      {
+        topic_id: 0,
+        label: 'Product Quality',
+        keywords: ['product'],
+        size: 2,
+        avg_sentiment: 0.7,
+        sentiment_distribution: { positive: 1, neutral: 1 },
+        languages: { en: 2 },
+        representative_docs: [],
+      },
+    ],
+    links: [],
+  },
+  data_quality: {
+    total_entries: 3,
+    low_confidence_count: 0,
+    low_confidence_entries: [],
+    mixed_language_count: 0,
+    mixed_language_entries: [],
+    duplicate_count: 0,
+    duplicate_entries: [],
+    avg_confidence: 0.843,
+    language_distribution: { en: 3 },
+  },
+  anomalies: [],
+  summary: {
+    total_entries: 3,
+    avg_sentiment: 0.533,
+    dominant_sentiment: 'positive',
+    num_topics: 2,
+    top_topics: [
+      { topic_id: 0, label: 'Product Quality', keywords: ['product'], size: 2 },
+      { topic_id: 1, label: 'Customer Service', keywords: ['service'], size: 1 },
+    ],
+    languages_detected: ['en'],
+    date_range: { start: '2024-01-01', end: '2024-01-03' },
+  },
+};
+
+export const handlers = [
+  http.get('/api/v1/jobs', () => {
+    return HttpResponse.json([mockJobStatus]);
+  }),
+
+  http.get('/api/v1/jobs/:jobId', () => {
+    return HttpResponse.json(mockAnalysisResult);
+  }),
+
+  http.get('/api/v1/jobs/:jobId/status', () => {
+    return HttpResponse.json(mockJobStatus);
+  }),
+
+  http.post('/api/v1/upload', () => {
+    return HttpResponse.json(mockJobStatus);
+  }),
+
+  http.post('/api/v1/jobs/:jobId/filter', () => {
+    return HttpResponse.json({
+      total: 3,
+      page: 1,
+      entries: mockAnalysisResult.entries,
+    });
+  }),
+
+  http.post('/api/v1/jobs/:jobId/compare', () => {
+    return HttpResponse.json({
+      segment_a: mockAnalysisResult.summary,
+      segment_b: mockAnalysisResult.summary,
+      sentiment_delta: 0.1,
+      topic_changes: [],
+      new_topics: [],
+      disappeared_topics: [],
+    });
+  }),
+
+  http.get('/health', () => {
+    return HttpResponse.json({
+      status: 'healthy',
+      version: '1.0.0',
+      models_loaded: true,
+      redis_connected: true,
+      uptime_seconds: 100,
+    });
+  }),
+];
+
+export const server = setupServer(...handlers);
+export { mockAnalysisResult, mockJobStatus };

frontend/src/__tests__/components.test.tsx

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { BrowserRouter } from 'react-router-dom';
+import { server } from '../__mocks__/handlers';
+import { Sidebar } from '../components/layout/Sidebar';
+import { Alert } from '../components/common/Alert';
+import { Skeleton } from '../components/common/Skeleton';
+import { DataQualityPanel } from '../components/quality/DataQualityPanel';
+import type { DataQualityReport } from '../types';
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe('Sidebar', () => {
+  it('renders navigation items', () => {
+    render(
+      <BrowserRouter>
+        <Sidebar theme="dark" onToggleTheme={() => {}} />
+      </BrowserRouter>,
+    );
+
+    expect(screen.getByText('Dashboard')).toBeInTheDocument();
+    expect(screen.getByText('Upload Data')).toBeInTheDocument();
+    expect(screen.getByText('Data Quality')).toBeInTheDocument();
+    expect(screen.getByText('Compare')).toBeInTheDocument();
+  });
+
+  it('renders theme toggle button', () => {
+    render(
+      <BrowserRouter>
+        <Sidebar theme="dark" onToggleTheme={() => {}} />
+      </BrowserRouter>,
+    );
+
+    expect(screen.getByText('Light Mode')).toBeInTheDocument();
+  });
+
+  it('shows dark mode text when theme is light', () => {
+    render(
+      <BrowserRouter>
+        <Sidebar theme="light" onToggleTheme={() => {}} />
+      </BrowserRouter>,
+    );
+
+    expect(screen.getByText('Dark Mode')).toBeInTheDocument();
+  });
+});
+
+describe('Alert', () => {
+  it('renders danger alert', () => {
+    render(<Alert type="danger" message="Something went wrong" />);
+    expect(screen.getByText('Something went wrong')).toBeInTheDocument();
+  });
+
+  it('renders success alert', () => {
+    render(<Alert type="success" message="Operation completed" />);
+    expect(screen.getByText('Operation completed')).toBeInTheDocument();
+  });
+
+  it('calls onDismiss when close button clicked', async () => {
+    const onDismiss = vi.fn();
+    render(<Alert type="warning" message="Warning" onDismiss={onDismiss} />);
+
+    const dismissBtn = screen.getByLabelText('Dismiss');
+    dismissBtn.click();
+    expect(onDismiss).toHaveBeenCalledOnce();
+  });
+});
+
+describe('Skeleton', () => {
+  it('renders loading skeleton', () => {
+    render(<Skeleton variant="text" count={3} />);
+    const skeletons = screen.getAllByRole('status');
+    expect(skeletons).toHaveLength(3);
+  });
+});
+
+describe('DataQualityPanel', () => {
+  const mockReport: DataQualityReport = {
+    total_entries: 100,
+    low_confidence_count: 5,
+    low_confidence_entries: ['1', '2', '3', '4', '5'],
+    mixed_language_count: 3,
+    mixed_language_entries: ['6', '7', '8'],
+    duplicate_count: 2,
+    duplicate_entries: ['9', '10'],
+    avg_confidence: 0.85,
+    language_distribution: { en: 80, es: 12, fr: 8 },
+  };
+
+  it('renders quality stats', () => {
+    render(<DataQualityPanel report={mockReport} />);
+
+    expect(screen.getByText('5')).toBeInTheDocument();
+    expect(screen.getByText('3')).toBeInTheDocument();
+    expect(screen.getByText('2')).toBeInTheDocument();
+  });
+
+  it('shows health score', () => {
+    render(<DataQualityPanel report={mockReport} />);
+    expect(screen.getByText('Data Health Score')).toBeInTheDocument();
+  });
+
+  it('displays language distribution', () => {
+    render(<DataQualityPanel report={mockReport} />);
+    expect(screen.getByText('en: 80')).toBeInTheDocument();
+    expect(screen.getByText('es: 12')).toBeInTheDocument();
+  });
+
+  it('shows warning when issues exist', () => {
+    render(<DataQualityPanel report={mockReport} />);
+    expect(screen.getByText(/data quality issue/i)).toBeInTheDocument();
+  });
+});