feat: initial HF Spaces deployment

.gitignore

@@ -0,0 +1,10 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+saved_articles.json
+benchmark_results/
+debug_adapters.py
+truthscan_report.*
+truthscan_test.py
+setup_test_env.bat

Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/benchmark.py

@@ -0,0 +1,240 @@
+"""
+Moduł benchmarkowania modeli NLP.
+
+Mierzy czas inferencji, rozkład sentymentów i prawdopodobieństwo fake news
+dla każdego adaptera (roberta, xlm-roberta, norbert) na próbce tekstów
+z trzech grup językowych (en, pl, no).
+
+Użycie standalone:
+    python -m app.benchmark
+
+Użycie z API:
+    GET /benchmark
+    GET /benchmark?adapters=roberta,xlm-roberta&langs=en,pl
+"""
+
+import csv
+import json
+import time
+from collections import Counter
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .nlp_service import get_adapter, ModelAdapter, analyze_news
+
+# ---------------------------------------------------------------------------
+# Próbka tekstów testowych
+# ---------------------------------------------------------------------------
+
+SAMPLE_TEXTS: Dict[str, List[str]] = {
+    "en": [
+        "The government announced new economic reforms to boost growth and reduce unemployment.",
+        "Flooding devastated coastal towns overnight, leaving thousands homeless.",
+        "Scientists discover a new vaccine that shows 95% efficacy against the virus.",
+        "Stock markets surged to record highs after positive inflation data.",
+        "A major scandal erupted as leaked documents exposed corporate corruption.",
+        "The peace talks collapsed after both sides failed to reach an agreement.",
+        "Renewable energy investments hit an all-time high this quarter.",
+        "Crime rates in the capital have dropped significantly over the past year.",
+    ],
+    "pl": [
+        "Rząd ogłosił nowe reformy gospodarcze mające na celu pobudzenie wzrostu.",
+        "Powódź zniszczyła nadmorskie miejscowości, tysiące osób zostało bez dachu.",
+        "Naukowcy odkryli szczepionkę o 95-procentowej skuteczności przeciw wirusowi.",
+        "Giełda osiągnęła rekordowe poziomy po pozytywnych danych o inflacji.",
+        "Wybuchł wielki skandal po ujawnieniu dokumentów o korupcji korporacyjnej.",
+        "Rozmowy pokojowe załamały się po niepowodzeniu negocjacji.",
+        "Inwestycje w energię odnawialną osiągnęły historyczny rekord w tym kwartale.",
+        "Wskaźniki przestępczości w stolicy znacząco spadły w ciągu ostatniego roku.",
+    ],
+    "no": [
+        "Regjeringen kunngjorde nye økonomiske reformer for å øke veksten.",
+        "Flom ødela kystbyer over natten og etterlot tusenvis uten hjem.",
+        "Forskere oppdaget en vaksine med 95 prosent effektivitet mot viruset.",
+        "Aksjemarkedene steg til rekordhøyder etter positive inflasjonsdata.",
+        "En stor skandale brøt ut da lekkede dokumenter avslørte korrupsjon.",
+        "Fredssamtalene brøt sammen etter at begge sider ikke klarte å bli enige.",
+        "Investeringer i fornybar energi nådde en historisk topp dette kvartalet.",
+        "Kriminalitetsratene i hovedstaden har falt betydelig det siste året.",
+    ],
+}
+
+# ---------------------------------------------------------------------------
+# Typy wyników
+# ---------------------------------------------------------------------------
+
+BenchmarkResult = Dict  # TypedDict zastąpiony zwykłym Dict dla czytelności
+
+# ---------------------------------------------------------------------------
+# Funkcje benchmarkowania
+# ---------------------------------------------------------------------------
+
+def _run_single(
+    adapter: ModelAdapter,
+    text: str,
+    lang: str,
+) -> Dict:
+    """Uruchamia analyze_news dla jednego tekstu i mierzy czas."""
+    start = time.perf_counter()
+    result = analyze_news(text, lang=lang, adapter=adapter)
+    elapsed_ms = (time.perf_counter() - start) * 1000
+    return {**result, "inference_time_ms": elapsed_ms}
+
+
+def run_benchmark(
+    adapter_names: Optional[List[str]] = None,
+    langs: Optional[List[str]] = None,
+) -> List[BenchmarkResult]:
+    """
+    Uruchamia benchmark dla wskazanych adapterów i języków.
+
+    Args:
+        adapter_names: Lista nazw adapterów; None = wszystkie trzy.
+        langs:         Lista kodów języków; None = ['en', 'pl', 'no'].
+
+    Returns:
+        Lista słowników z wynikami — jeden wpis na kombinację adapter × język.
+    """
+    if adapter_names is None:
+        adapter_names = ["roberta", "xlm-roberta", "norbert"]
+    if langs is None:
+        langs = ["en", "pl", "no"]
+
+    results: List[BenchmarkResult] = []
+
+    for adapter_name in adapter_names:
+        try:
+            adapter = get_adapter(adapter_name)
+        except ValueError as exc:
+            results.append({
+                "adapter_name": adapter_name,
+                "error": str(exc),
+            })
+            continue
+
+        for lang in langs:
+            texts = SAMPLE_TEXTS.get(lang, [])
+            if not texts:
+                continue
+
+            per_text: List[Dict] = []
+            for text in texts:
+                try:
+                    per_text.append(_run_single(adapter, text, lang))
+                except Exception as exc:
+                    per_text.append({
+                        "sentiment": None,
+                        "fake_probability": None,
+                        "sentiment_score": None,
+                        "inference_time_ms": None,
+                        "error": str(exc),
+                    })
+
+            # Agregacja
+            valid = [r for r in per_text if r.get("inference_time_ms") is not None]
+            times = [r["inference_time_ms"] for r in valid]
+            fakes = [r["fake_probability"] for r in valid if r.get("fake_probability") is not None]
+            sentiments = [r["sentiment"] for r in valid if r.get("sentiment")]
+
+            results.append({
+                "adapter_name": adapter_name,
+                "language": lang,
+                "sample_size": len(texts),
+                "successful_runs": len(valid),
+                "avg_inference_time_ms": round(sum(times) / len(times), 2) if times else None,
+                "min_inference_time_ms": round(min(times), 2) if times else None,
+                "max_inference_time_ms": round(max(times), 2) if times else None,
+                "avg_fake_probability": round(sum(fakes) / len(fakes), 2) if fakes else None,
+                "sentiments_distribution": dict(Counter(sentiments)),
+                "per_text": per_text,
+            })
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Eksport wyników
+# ---------------------------------------------------------------------------
+
+def export_json(results: List[BenchmarkResult], path: Path) -> None:
+    """Zapisuje pełne wyniki (z per_text) do pliku JSON."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as fh:
+        json.dump(results, fh, ensure_ascii=False, indent=2)
+
+
+def export_csv(results: List[BenchmarkResult], path: Path) -> None:
+    """
+    Zapisuje wyniki zbiorcze (bez per_text) do pliku CSV.
+    Jeden wiersz = jedna kombinacja adapter × język.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    summary_fields = [
+        "adapter_name", "language", "sample_size", "successful_runs",
+        "avg_inference_time_ms", "min_inference_time_ms", "max_inference_time_ms",
+        "avg_fake_probability", "sentiments_distribution",
+    ]
+    with open(path, "w", newline="", encoding="utf-8") as fh:
+        writer = csv.DictWriter(fh, fieldnames=summary_fields, extrasaction="ignore")
+        writer.writeheader()
+        for row in results:
+            if "error" in row:
+                continue
+            flat = {k: row.get(k) for k in summary_fields}
+            # Rozkład sentymentów jako string JSON w komórce CSV
+            flat["sentiments_distribution"] = json.dumps(
+                row.get("sentiments_distribution", {}), ensure_ascii=False
+            )
+            writer.writerow(flat)
+
+
+def _summary_only(results: List[BenchmarkResult]) -> List[BenchmarkResult]:
+    """Zwraca wyniki bez pola per_text (lżejsza odpowiedź HTTP)."""
+    return [{k: v for k, v in r.items() if k != "per_text"} for r in results]
+
+
+# ---------------------------------------------------------------------------
+# Uruchomienie standalone
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="TruthScan NLP benchmark")
+    parser.add_argument(
+        "--adapters", default="roberta,xlm-roberta,norbert",
+        help="Przecinkowa lista adapterów (domyślnie: wszystkie)",
+    )
+    parser.add_argument(
+        "--langs", default="en,pl,no",
+        help="Przecinkowa lista języków (domyślnie: en,pl,no)",
+    )
+    parser.add_argument(
+        "--out-dir", default="benchmark_results",
+        help="Katalog wyjściowy dla plików JSON i CSV",
+    )
+    args = parser.parse_args()
+
+    adapter_names = [a.strip() for a in args.adapters.split(",")]
+    langs = [l.strip() for l in args.langs.split(",")]
+    out_dir = Path(args.out_dir)
+
+    print(f"Uruchamiam benchmark: adaptery={adapter_names}, języki={langs}")
+    results = run_benchmark(adapter_names=adapter_names, langs=langs)
+
+    json_path = out_dir / "benchmark.json"
+    csv_path = out_dir / "benchmark.csv"
+    export_json(results, json_path)
+    export_csv(results, csv_path)
+
+    print(f"Wyniki zapisane: {json_path}, {csv_path}")
+    for r in _summary_only(results):
+        if "error" in r:
+            print(f"  [{r['adapter_name']}] BŁĄD: {r['error']}")
+        else:
+            print(
+                f"  [{r['adapter_name']:12s} / {r['language']}] "
+                f"avg={r['avg_inference_time_ms']} ms  "
+                f"fake={r['avg_fake_probability']}%  "
+                f"sentiments={r['sentiments_distribution']}"
+            )

app/config.py

@@ -0,0 +1,61 @@
+"""
+Centralna konfiguracja aplikacji oraz stałe wykorzystywane w wielu modułach.
+"""
+
+import os
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+except ImportError:
+    pass  # python-dotenv opcjonalne; zmienne można też ustawić w środowisku
+
+# Konfiguracja CORS
+# Uwaga: credentials=True jest niekompatybilne z origins=["*"] w przeglądarkach
+# (spec CORS odrzuca tę kombinację). Dla dev/thesis używamy credentials=False.
+CORS_ALLOW_ORIGINS = ["*"]
+CORS_ALLOW_CREDENTIALS = False
+CORS_ALLOW_METHODS = ["GET", "POST", "DELETE", "OPTIONS"]
+CORS_ALLOW_HEADERS = ["*"]
+
+# Lista obsługiwanych źródeł RSS
+NEWS_FEEDS = {
+    # Angielskie
+    "BBC":          "https://feeds.bbci.co.uk/news/rss.xml",
+    "CNN":          "http://rss.cnn.com/rss/edition.rss",
+    "NYTimes":      "https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml",
+    "Guardian":     "https://www.theguardian.com/world/rss",
+    "AlJazeera":    "https://www.aljazeera.com/xml/rss/all.xml",
+    # Polskie
+    "Money":        "https://www.money.pl/rss/",
+    "PolsatNews":   "https://www.polsatnews.pl/rss/wszystkie.xml",
+    "TVN24":        "https://tvn24.pl/najnowsze.xml",
+    "SpidersWeb":   "https://spidersweb.pl/feed",
+    "Bankier":      "https://www.bankier.pl/rss/wiadomosci.xml",
+    # Norweskie
+    "NRK":          "https://www.nrk.no/toppsaker.rss",
+    "VG":           "https://www.vg.no/rss/feed/?limit=10",
+    "E24":          "https://e24.no/rss",
+    "Aftenposten":  "https://www.aftenposten.no/rss",
+}
+
+# Mapowanie wyników analizy sentymentu na etykiety językowe
+SENTIMENT_MAP = {
+    "negative": {"pl": "Negatywne", "en": "Negative", "no": "Negativt"},
+    "neutral":  {"pl": "Neutralne", "en": "Neutral",  "no": "Nøytralt"},
+    "positive": {"pl": "Pozytywne", "en": "Positive", "no": "Positivt"},
+}
+
+# Ścieżka do pliku z zapisanymi artykułami
+SAVED_FILE = Path("saved_articles.json")
+
+# Czas życia cache (sekundy)
+CACHE_TTL_SECONDS = 120
+
+# Konfiguracja Redis (jeśli używany jako backend cache)
+REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
+CACHE_TTL = 300
+
+# Klucz API Anthropic (Claude)
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

app/main.py

@@ -0,0 +1,55 @@
+"""
+Główna konfiguracja i uruchomienie aplikacji FastAPI.
+"""
+
+from fastapi import FastAPI, Request
+from fastapi.responses import Response
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+
+from .routes import misc, news, saved, compare
+
+app = FastAPI()
+
+_CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "*",
+    "Access-Control-Max-Age": "86400",
+}
+
+
+@app.middleware("http")
+async def add_cors_headers(request: Request, call_next):
+    # Odpowiedź na preflight OPTIONS bez przekazywania do routera
+    if request.method == "OPTIONS":
+        return Response(status_code=204, headers=_CORS_HEADERS)
+
+    response = await call_next(request)
+
+    for key, value in _CORS_HEADERS.items():
+        response.headers[key] = value
+
+    return response
+
+
+@app.on_event("startup")
+async def startup():
+    FastAPICache.init(InMemoryBackend(), prefix="news-cache")
+    print("✓ Cache initialized (5 minut TTL)")
+
+
+app.include_router(misc.router)
+app.include_router(news.router)
+app.include_router(saved.router)
+app.include_router(compare.router)
+
+
+@app.get("/")
+async def root():
+    return {"message": "TruthScan API", "status": "running", "cached": True}
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}

app/models.py

@@ -0,0 +1,16 @@
+"""
+Modele danych wykorzystywane do walidacji i serializacji artykułów.
+"""
+
+from pydantic import BaseModel
+
+
+class Article(BaseModel):
+    # Model artykułu wykorzystywany w komunikacji API
+    title: str
+    link: str
+    summary: str
+    published: str
+    sentiment: str
+    fake_probability: float
+    source: str

app/nlp_service.py

@@ -0,0 +1,433 @@
+"""
+Serwis NLP z architekturą plug-in.
+
+Każdy model jest reprezentowany przez adapter dziedziczący z ModelAdapter.
+Publiczne API (analyze_news, analyze_news_batch) pozostaje niezmienione,
+więc routes/news.py nie wymaga modyfikacji.
+
+Fake news detection używa jednej globalnej instancji BART (_shared_bart)
+współdzielonej przez wszystkie adaptery — model ładowany jest leniwie
+przy pierwszym wywołaniu get_shared_bart().
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional
+from concurrent.futures import ThreadPoolExecutor
+
+from transformers import pipeline
+
+from .config import SENTIMENT_MAP
+
+
+# ---------------------------------------------------------------------------
+# Współdzielony BART do wykrywania fake news (jeden egzemplarz dla wszystkich)
+# ---------------------------------------------------------------------------
+
+_shared_bart = None
+
+
+def get_shared_bart():
+    """
+    Zwraca globalną instancję potoku zero-shot-classification (BART).
+    Ładuje model przy pierwszym wywołaniu (lazy init).
+    """
+    global _shared_bart
+    if _shared_bart is None:
+        _shared_bart = pipeline(
+            "zero-shot-classification",
+            model="facebook/bart-large-mnli",
+        )
+    return _shared_bart
+
+
+def analyze_fake_news_shared(text: str) -> float:
+    """
+    Klasyfikuje tekst jako real/fake używając współdzielonego BART.
+
+    Zwraca:
+        Prawdopodobieństwo fake news w procentach (0.0 – 100.0).
+    """
+    result = get_shared_bart()(text, candidate_labels=["real", "fake"])
+    for lbl, score in zip(result["labels"], result["scores"]):
+        if lbl == "fake":
+            return round(score * 100, 2)
+    return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Klasa bazowa
+# ---------------------------------------------------------------------------
+
+class ModelAdapter(ABC):
+    """
+    Abstrakcyjny adapter modelu NLP.
+
+    Każdy konkretny adapter implementuje:
+      - analyze_sentiment(text) -> {"label": str, "score": float}
+      - analyze_fake_news(text) -> {"labels": List[str], "scores": List[float]}
+
+    analyze_fake_news deleguje do współdzielonego BART (get_shared_bart),
+    więc każda podklasa może użyć domyślnej implementacji z tej klasy bazowej.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        ...
+
+    @property
+    @abstractmethod
+    def supported_languages(self) -> List[str]:
+        ...
+
+    @abstractmethod
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        """
+        Zwraca {"label": str, "score": float}
+        gdzie label to: 'positive' | 'negative' | 'neutral'
+        """
+        ...
+
+    def analyze_fake_news(self, text: str) -> Dict[str, Any]:
+        """
+        Klasyfikuje tekst używając współdzielonego BART.
+        Podklasy mogą nadpisać, ale domyślnie korzystają z _shared_bart.
+        """
+        result = get_shared_bart()(text, candidate_labels=["real", "fake"])
+        return {"labels": result["labels"], "scores": result["scores"]}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _extract_pipeline_result(adapter_name: str, raw: Any) -> Dict[str, Any]:
+    """
+    Bezpiecznie wyciąga słownik {label, score} z surowego outputu pipeline.
+
+    Pipeline text-classification może zwrócić:
+      - [{"label": ..., "score": ...}]            (return_all_scores=False)
+      - [[{"label": ..., "score": ...}, ...]]      (return_all_scores=True / top_k=None)
+    """
+    print(f"[DEBUG] {adapter_name}: raw = {raw!r}")
+    try:
+        item = raw[0]
+    except (IndexError, TypeError) as exc:
+        print(f"[DEBUG] {adapter_name}: raw[0] failed: {exc}")
+        return {"label": "", "score": 0.0}
+
+    if isinstance(item, dict):
+        result = item
+    elif isinstance(item, list):
+        # return_all_scores=True zwraca listę list — bierzemy element o najwyższym score
+        if not item:
+            print(f"[DEBUG] {adapter_name}: item jest pustą listą")
+            return {"label": "", "score": 0.0}
+        result = max(item, key=lambda x: x.get("score", 0.0))
+    else:
+        print(f"[DEBUG] {adapter_name}: nieoczekiwany typ item: {type(item)!r}, raw={raw!r}")
+        return {"label": "", "score": 0.0}
+
+    print(f"[DEBUG] {adapter_name}: extracted = {result!r}")
+    return result
+
+
+def _normalize_sentiment_label(raw_label: str) -> str:
+    label = (raw_label or "").strip().lower()
+
+    _POSITIVE = {"positive", "pos", "label_2", "2", "very positive"}
+    _NEGATIVE = {"negative", "neg", "label_0", "0", "very negative"}
+    # "mixed" (NorBERT3 sentence-sentiment) → traktujemy jako neutral
+    _NEUTRAL  = {"neutral", "mixed", "label_1"}
+
+    if label in _POSITIVE or label.startswith("pos"):
+        return "positive"
+    if label in _NEGATIVE or label.startswith("neg"):
+        return "negative"
+    if label in _NEUTRAL:
+        return "neutral"
+    return "neutral"
+
+
+# ---------------------------------------------------------------------------
+# Adaptery — każdy ładuje tylko swój model sentymentu
+# ---------------------------------------------------------------------------
+
+class RoBERTaAdapter(ModelAdapter):
+    """
+    Adapter anglojęzyczny.
+      sentyment: cardiffnlp/twitter-roberta-base-sentiment-latest
+      fake news: współdzielony BART (ModelAdapter.analyze_fake_news)
+    """
+
+    def __init__(self) -> None:
+        self._sentiment_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model="cardiffnlp/twitter-roberta-base-sentiment-latest",
+                return_all_scores=False,
+            )
+
+    @property
+    def name(self) -> str:
+        return "roberta"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["en"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        raw = self._sentiment_pipe(text)
+        result = _extract_pipeline_result(self.name, raw)
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+
+class XLMRoBERTaAdapter(ModelAdapter):
+    """
+    Adapter wielojęzyczny (pl, en, no).
+      sentyment: cardiffnlp/twitter-xlm-roberta-base-sentiment
+      fake news: współdzielony BART
+    """
+
+    def __init__(self) -> None:
+        self._sentiment_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model="cardiffnlp/twitter-xlm-roberta-base-sentiment",
+                return_all_scores=False,
+            )
+
+    @property
+    def name(self) -> str:
+        return "xlm-roberta"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["pl", "en", "no"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        raw = self._sentiment_pipe(text)
+        result = _extract_pipeline_result(self.name, raw)
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+
+class HerBERTAdapter(ModelAdapter):
+    """
+    Adapter dla języka polskiego (HerBERT).
+      sentyment: allegro/herbert-base-cased (model bazowy — wymaga fine-tuningu)
+      fake news: współdzielony BART
+    """
+
+    SENTIMENT_MODEL: str = "allegro/herbert-base-cased"
+
+    def __init__(self, sentiment_model: Optional[str] = None) -> None:
+        self._sentiment_model_id = sentiment_model or self.SENTIMENT_MODEL
+        self._sentiment_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model=self._sentiment_model_id,
+                return_all_scores=False,
+            )
+
+    @property
+    def name(self) -> str:
+        return "herbert"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["pl"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        raw = self._sentiment_pipe(text)
+        result = _extract_pipeline_result(self.name, raw)
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+
+class NorBERTAdapter(ModelAdapter):
+    """
+    Adapter dla języka norweskiego.
+      sentyment: cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual
+                 (wielojęzyczny XLM-RoBERTa Cardiff, obsługuje norweski)
+      fake news: współdzielony BART
+    """
+
+    # cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual —
+    # wielojęzyczny model Cardiff fine-tuned na sentymencie (obsługuje norweski),
+    # standardowa architektura XLM-RoBERTa kompatybilna z pipeline("text-classification").
+    SENTIMENT_MODEL: str = "cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual"
+
+    def __init__(self, sentiment_model: Optional[str] = None) -> None:
+        self._sentiment_model_id = sentiment_model or self.SENTIMENT_MODEL
+        self._sentiment_pipe = None
+
+    def _load(self) -> None:
+        if self._sentiment_pipe is None:
+            self._sentiment_pipe = pipeline(
+                "text-classification",
+                model=self._sentiment_model_id,
+                return_all_scores=False,
+            )
+
+    @property
+    def name(self) -> str:
+        return "norbert"
+
+    @property
+    def supported_languages(self) -> List[str]:
+        return ["no"]
+
+    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
+        self._load()
+        raw = self._sentiment_pipe(text)
+        result = _extract_pipeline_result(self.name, raw)
+        return {
+            "label": _normalize_sentiment_label(result.get("label", "")),
+            "score": float(result.get("score", 0.0)),
+        }
+
+
+# ---------------------------------------------------------------------------
+# Rejestr adapterów — lazy initialization
+# ---------------------------------------------------------------------------
+
+_REGISTRY: Dict[str, ModelAdapter] = {}
+_active_adapter: Optional[ModelAdapter] = None
+executor = ThreadPoolExecutor(max_workers=3)
+_BUILTIN_ADAPTERS = {"roberta", "xlm-roberta", "herbert", "norbert"}
+
+
+def _init_registry() -> None:
+    if _REGISTRY:
+        return
+    _REGISTRY["roberta"]     = RoBERTaAdapter()
+    _REGISTRY["xlm-roberta"] = XLMRoBERTaAdapter()
+    _REGISTRY["herbert"]     = HerBERTAdapter()
+    _REGISTRY["norbert"]     = NorBERTAdapter()
+
+
+def get_adapter(name: str) -> ModelAdapter:
+    _init_registry()
+    if name not in _REGISTRY:
+        raise ValueError(
+            f"Nieznany adapter: '{name}'. Dostępne: {list(_REGISTRY.keys())}"
+        )
+    return _REGISTRY[name]
+
+
+def set_active_adapter(name: str) -> None:
+    global _active_adapter
+    _active_adapter = get_adapter(name)
+
+
+def register_adapter(adapter: ModelAdapter) -> None:
+    _init_registry()
+    _REGISTRY[adapter.name] = adapter
+
+
+def _get_active_adapter() -> ModelAdapter:
+    global _active_adapter
+    if _active_adapter is None:
+        _active_adapter = get_adapter("roberta")
+    return _active_adapter
+
+
+# ---------------------------------------------------------------------------
+# Publiczne API
+# ---------------------------------------------------------------------------
+
+def analyze_news(
+    text: str,
+    lang: str = "pl",
+    adapter: Optional[ModelAdapter] = None,
+) -> dict:
+    """
+    Analizuje pojedynczy tekst pod kątem sentymentu i fake news.
+
+    Returns:
+        {"sentiment": str, "fake_probability": float, "sentiment_score": float}
+    """
+    _neutral = SENTIMENT_MAP["neutral"].get(lang, "Neutral")
+
+    if not text or len(text.strip()) < 10:
+        return {"sentiment": _neutral, "fake_probability": 0.0, "sentiment_score": 0.0}
+
+    _adapter = adapter or _get_active_adapter()
+
+    try:
+        sentiment_result = _adapter.analyze_sentiment(text)
+        fake_result = _adapter.analyze_fake_news(text)
+    except Exception:
+        return {"sentiment": _neutral, "fake_probability": 0.0, "sentiment_score": 0.0}
+
+    label = sentiment_result.get("label", "neutral")
+    sentiment_translated = SENTIMENT_MAP.get(label, {}).get(lang, _neutral)
+
+    fake_score = 0.0
+    for lbl, score in zip(fake_result["labels"], fake_result["scores"]):
+        if lbl == "fake":
+            fake_score = score
+            break
+
+    return {
+        "sentiment": sentiment_translated,
+        "fake_probability": round(fake_score * 100, 2),
+        "sentiment_score": round(float(sentiment_result.get("score", 0.0)), 2),
+    }
+
+
+def analyze_news_batch(
+    texts: List[str],
+    lang: str = "pl",
+    adapter: Optional[ModelAdapter] = None,
+) -> List[Dict[str, Any]]:
+    """Analiza wielu tekstów w trybie batch z użyciem ThreadPoolExecutor."""
+    if not texts:
+        return []
+
+    _adapter = adapter or _get_active_adapter()
+    results: List[Dict[str, Any]] = []
+    batch_size = 3
+
+    batches = [texts[i:i + batch_size] for i in range(0, len(texts), batch_size)]
+
+    for batch in batches:
+        futures = [
+            executor.submit(analyze_news, text, lang, _adapter)
+            for text in batch
+        ]
+        for future in futures:
+            try:
+                results.append(future.result())
+            except Exception:
+                _neutral = SENTIMENT_MAP["neutral"].get(lang, "Neutral")
+                results.append(
+                    {"sentiment": _neutral, "fake_probability": 0.0, "sentiment_score": 0.0}
+                )
+
+    return results
+
+
+def analyze_news_single(text: str, lang: str) -> Dict[str, Any]:
+    """Wrapper dla analizy pojedynczego tekstu (używany w batch processing)."""
+    return analyze_news(text, lang)

app/routes/compare.py

@@ -0,0 +1,372 @@
+"""
+Endpoint porównujący wyniki wszystkich adapterów NLP dla jednego tekstu.
+
+Architektura:
+  - fake news: jeden wspólny wynik z _shared_bart (BART large MNLI)
+  - sentyment: każdy z 4 adapterów używa własnego modelu
+
+Zwraca:
+  - shared_fake_probability: float  — wynik BART (jeden dla wszystkich)
+  - results: lista wyników sentymentu per adapter z czasem inferencji
+  - explanation: wyjaśnienie różnic wygenerowane przez Claude API
+"""
+
+import time
+from typing import List
+
+import anthropic
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..config import ANTHROPIC_API_KEY, SENTIMENT_MAP
+from ..nlp_service import get_adapter, analyze_fake_news_shared
+
+router = APIRouter()
+
+ADAPTER_NAMES = ["roberta", "xlm-roberta", "norbert", "herbert"]
+
+LANG_NAMES = {
+    "pl": "polski",
+    "en": "angielski",
+    "no": "norweski",
+}
+
+# Język odpowiedzi Claude zależny od lang w żądaniu
+RESPONSE_LANG = {
+    "pl": "polskim",
+    "en": "English",
+    "no": "norsk",
+}
+
+# Instrukcja do Claude w danym języku
+EXPLAIN_INSTRUCTION = {
+    "pl": (
+        "Wyjaśnij w 3–4 zdaniach po polsku dlaczego modele oceniają sentyment tego tekstu tak jak oceniają. "
+        "Uwzględnij: (1) czy tekst jest w języku {lang_name} i jak to wpływa na modele trenowane na innych językach, "
+        "(2) co powoduje ewentualne rozbieżności między modelami, "
+        "(3) który model jest prawdopodobnie najbardziej trafny dla tego języka i dlaczego. "
+        "Pisz czystym tekstem — bez formatowania markdown, bez gwiazdek, bez nagłówków, bez list numerowanych."
+    ),
+    "en": (
+        "Explain in 3–4 sentences in English why the models assess the sentiment of this text the way they do. "
+        "Cover: (1) whether the text is in {lang_name} and how that affects models trained on other languages, "
+        "(2) what causes any disagreements between the models, "
+        "(3) which model is likely most accurate for this language and why. "
+        "Write in plain text — no markdown, no asterisks, no headings, no numbered lists."
+    ),
+    "no": (
+        "Forklar på norsk i 3–4 setninger hvorfor modellene vurderer sentimentet til denne teksten slik de gjør. "
+        "Ta med: (1) om teksten er på {lang_name} og hvordan det påvirker modeller trent på andre språk, "
+        "(2) hva som forårsaker eventuelle uenigheter mellom modellene, "
+        "(3) hvilken modell som sannsynligvis er mest nøyaktig for dette språket og hvorfor. "
+        "Skriv i ren tekst — ingen markdown, ingen stjerner, ingen overskrifter, ingen nummererte lister."
+    ),
+}
+
+ADAPTER_DESCRIPTIONS = {
+    "roberta":     "RoBERTa (trenowany na angielskich tweetach)",
+    "xlm-roberta": "XLM-RoBERTa (wielojęzyczny, pl/en/no)",
+    "norbert":     "NorBERT 3 (norweski model bazowy)",
+    "herbert":     "HerBERT (polski model bazowy)",
+}
+
+
+CHART_COMMENT_PROMPT = {
+    "pl": (
+        "Na podstawie poniższych danych fake-news probability (0–100%) dla {n} źródeł mediów "
+        "napisz dokładnie 2–3 zdania komentarza analitycznego po polsku. "
+        "Wskaż źródło z najwyższym i najniższym wynikiem oraz co to może oznaczać dla czytelnika. "
+        "Bądź zwięzły i obiektywny. Pisz czystym tekstem — bez markdown, bez gwiazdek, bez list.\n\n"
+        "Dane:\n{rows}"
+    ),
+    "en": (
+        "Based on the following fake-news probability data (0–100%) for {n} media sources "
+        "write exactly 2–3 sentences of analytical commentary in English. "
+        "Identify the source with the highest and lowest score and what this might mean for readers. "
+        "Be concise and objective. Write in plain text — no markdown, no asterisks, no lists.\n\n"
+        "Data:\n{rows}"
+    ),
+    "no": (
+        "Basert på følgende fake-news sannsynlighetsdata (0–100 %) for {n} mediekilder "
+        "skriv nøyaktig 2–3 setninger med analytisk kommentar på norsk. "
+        "Pek på kilden med høyest og lavest score og hva dette kan bety for leseren. "
+        "Vær kortfattet og objektiv. Skriv i ren tekst — ingen markdown, ingen stjerner, ingen lister.\n\n"
+        "Data:\n{rows}"
+    ),
+}
+
+
+class ChartCommentRequest(BaseModel):
+    bars: list          # [{"label": "BBC", "value": 23.45}, ...]
+    lang: str = "pl"
+
+
+class ChartCommentResponse(BaseModel):
+    comment: str
+
+
+@router.post("/ai-chart-comment", response_model=ChartCommentResponse)
+def ai_chart_comment(request: ChartCommentRequest):
+    """Generuje krótki komentarz analityczny Claude do wykresu fake-news probability."""
+    if not request.bars:
+        raise HTTPException(status_code=422, detail="Brak danych wykresu.")
+
+    lang = request.lang if request.lang in CHART_COMMENT_PROMPT else "pl"
+
+    # Buduj czytelny opis danych (posortowany malejąco po value)
+    sorted_bars = sorted(request.bars, key=lambda b: b.get("value", 0), reverse=True)
+    rows = "\n".join(
+        f"  {b['label']}: {b.get('value', 0):.2f}%"
+        for b in sorted_bars
+        if b.get("label")
+    )
+    prompt = CHART_COMMENT_PROMPT[lang].format(n=len(sorted_bars), rows=rows)
+
+    if not ANTHROPIC_API_KEY:
+        return ChartCommentResponse(comment="[Brak klucza ANTHROPIC_API_KEY]")
+
+    try:
+        client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+        message = client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=300,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        comment = message.content[0].text.strip() if message.content else ""
+    except Exception as e:
+        comment = f"[Błąd Claude API: {e}]"
+
+    return ChartCommentResponse(comment=comment)
+
+
+EMOTION_COMMENT_PROMPT = {
+    "pl": (
+        "Na podstawie danych o emocjach w artykułach: "
+        "Pozytywne: {positive}, Neutralne: {neutral}, Negatywne: {negative} "
+        "(łącznie {total} artykułów) — napisz 2–3 zdania komentarza analitycznego po polsku. "
+        "Co dominujący sentyment mówi o obecnym klimacie medialnym? "
+        "Bądź zwięzły i obiektywny. Pisz czystym tekstem — bez markdown, bez gwiazdek, bez list."
+    ),
+    "en": (
+        "Based on emotion data from articles: "
+        "Positive: {positive}, Neutral: {neutral}, Negative: {negative} "
+        "(total {total} articles) — write 2–3 sentences of analytical commentary in English. "
+        "What does the dominant sentiment say about the current media climate? "
+        "Be concise and objective. Write in plain text — no markdown, no asterisks, no lists."
+    ),
+    "no": (
+        "Basert på emosjonelle data fra artikler: "
+        "Positive: {positive}, Nøytrale: {neutral}, Negative: {negative} "
+        "(totalt {total} artikler) — skriv 2–3 setninger med analytisk kommentar på norsk. "
+        "Hva sier det dominerende sentimentet om det nåværende mediaklimaet? "
+        "Vær kortfattet og objektiv. Skriv i ren tekst — ingen markdown, ingen stjerner, ingen lister."
+    ),
+}
+
+
+class EmotionCommentRequest(BaseModel):
+    positive: int = 0
+    neutral: int = 0
+    negative: int = 0
+    lang: str = "pl"
+
+
+class EmotionCommentResponse(BaseModel):
+    comment: str
+
+
+@router.post("/ai-emotion-comment", response_model=EmotionCommentResponse)
+def ai_emotion_comment(request: EmotionCommentRequest):
+    """Generuje krótki komentarz analityczny Claude do wykresu emocji."""
+    total = request.positive + request.neutral + request.negative
+    if total == 0:
+        raise HTTPException(status_code=422, detail="Brak danych emocji.")
+
+    lang = request.lang if request.lang in EMOTION_COMMENT_PROMPT else "pl"
+    prompt = EMOTION_COMMENT_PROMPT[lang].format(
+        positive=request.positive,
+        neutral=request.neutral,
+        negative=request.negative,
+        total=total,
+    )
+
+    if not ANTHROPIC_API_KEY:
+        return EmotionCommentResponse(comment="[Brak klucza ANTHROPIC_API_KEY]")
+
+    try:
+        client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+        message = client.messages.create(
+            model="claude-sonnet-4-20250514",
+            max_tokens=300,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        comment = message.content[0].text.strip() if message.content else ""
+    except Exception as e:
+        comment = f"[Błąd Claude API: {e}]"
+
+    return EmotionCommentResponse(comment=comment)
+
+
+class CompareRequest(BaseModel):
+    text: str
+    title: str = ""
+    source: str = ""
+    lang: str = "pl"
+
+
+class AdapterResult(BaseModel):
+    adapter: str
+    sentiment: str
+    sentiment_score: float
+    inference_time_ms: float
+
+
+class CompareResponse(BaseModel):
+    shared_fake_probability: float
+    results: List[AdapterResult]
+    explanation: str
+
+
+def _sentiment_only_with_timing(adapter_name: str, text: str, lang: str) -> AdapterResult:
+    """Uruchamia tylko analizę sentymentu i mierzy jej czas."""
+    adapter = get_adapter(adapter_name)
+    neutral = SENTIMENT_MAP["neutral"].get(lang, "Neutral")
+
+    if not text or len(text.strip()) < 10:
+        print(f"[DEBUG] {adapter_name}: tekst za krótki, zwracam neutral/0.0")
+        return AdapterResult(
+            adapter=adapter_name,
+            sentiment=neutral,
+            sentiment_score=0.0,
+            inference_time_ms=0.0,
+        )
+
+    start = time.perf_counter()
+    try:
+        sentiment_result = adapter.analyze_sentiment(text)
+    except Exception as exc:
+        elapsed = (time.perf_counter() - start) * 1000
+        print(f"[DEBUG] {adapter_name}: WYJĄTEK w analyze_sentiment: {type(exc).__name__}: {exc}")
+        return AdapterResult(
+            adapter=adapter_name,
+            sentiment=neutral,
+            sentiment_score=0.0,
+            inference_time_ms=round(elapsed, 1),
+        )
+    elapsed_ms = (time.perf_counter() - start) * 1000
+
+    print(f"[DEBUG] {adapter_name}: sentiment_result = {sentiment_result}")
+
+    raw_label = sentiment_result.get("label", "neutral")
+    raw_score = sentiment_result.get("score", None)
+
+    print(f"[DEBUG] {adapter_name}: raw_label={raw_label!r}  raw_score={raw_score!r}  type(score)={type(raw_score)}")
+
+    sentiment_translated = SENTIMENT_MAP.get(raw_label, {}).get(lang, neutral)
+    score_float = round(float(raw_score) if raw_score is not None else 0.0, 4)
+
+    print(f"[DEBUG] {adapter_name}: → sentiment={sentiment_translated!r}  score_float={score_float}  time={elapsed_ms:.1f}ms")
+
+    return AdapterResult(
+        adapter=adapter_name,
+        sentiment=sentiment_translated,
+        sentiment_score=score_float,
+        inference_time_ms=round(elapsed_ms, 1),
+    )
+
+
+def _build_prompt(
+    request: CompareRequest,
+    results: List[AdapterResult],
+    shared_fake_probability: float,
+) -> str:
+    lang_name = LANG_NAMES.get(request.lang, request.lang)
+    text_snippet = request.text[:600] + ("..." if len(request.text) > 600 else "")
+
+    header_parts = []
+    if request.title:
+        header_parts.append(f"Tytuł artykułu: {request.title}")
+    if request.source:
+        header_parts.append(f"Źródło: {request.source}")
+    header_parts.append(f"Język tekstu: {lang_name}")
+    header_parts.append(f"Prawdopodobieństwo fake news (BART, wspólne dla wszystkich modeli): {shared_fake_probability:.1f}%")
+    header_str = "\n".join(header_parts)
+
+    rows = "\n".join(
+        f"  {ADAPTER_DESCRIPTIONS[r.adapter]}: {r.sentiment} (pewność: {r.sentiment_score * 100:.0f}%, czas: {r.inference_time_ms:.0f} ms)"
+        for r in results
+    )
+
+    sentiments = [r.sentiment for r in results]
+    unique_sentiments = set(sentiments)
+    agreement = (
+        "zgodne" if len(unique_sentiments) == 1
+        else f"różne ({', '.join(unique_sentiments)})"
+    )
+
+    lang = request.lang
+    response_lang = RESPONSE_LANG.get(lang, "polskim")
+    instruction = EXPLAIN_INSTRUCTION.get(lang, EXPLAIN_INSTRUCTION["pl"]).format(
+        lang_name=lang_name
+    )
+
+    return f"""Odpowiedz w języku: {response_lang}.
+
+{header_str}
+
+Fragment tekstu:
+{text_snippet}
+
+Wyniki analizy sentymentu:
+{rows}
+
+Zgodność modeli: {agreement}
+
+{instruction}"""
+
+
+@router.post("/compare", response_model=CompareResponse)
+def compare_models(request: CompareRequest):
+    """
+    Analizuje tekst przez wszystkie 4 adaptery NLP:
+      - fake news: jeden wynik ze współdzielonego BART
+      - sentyment: każdy adapter osobno z pomiarem czasu
+    Zwraca wyniki + wyjaśnienie Claude API.
+    """
+    if not request.text or len(request.text.strip()) < 10:
+        raise HTTPException(status_code=422, detail="Tekst jest za krótki (min. 10 znaków).")
+
+    # Fake news — jeden wspólny wynik z BART (uruchamiamy raz)
+    try:
+        shared_fake_probability = analyze_fake_news_shared(request.text)
+    except Exception as e:
+        shared_fake_probability = 0.0
+
+    # Sentyment — każdy adapter osobno z pomiarem czasu
+    results: List[AdapterResult] = [
+        _sentiment_only_with_timing(name, request.text, request.lang)
+        for name in ADAPTER_NAMES
+    ]
+
+    # Wyjaśnienie Claude
+    explanation = ""
+    if ANTHROPIC_API_KEY:
+        try:
+            client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+            prompt = _build_prompt(request, results, shared_fake_probability)
+            message = client.messages.create(
+                model="claude-sonnet-4-20250514",
+                max_tokens=800,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            explanation = message.content[0].text if message.content else ""
+        except Exception as e:
+            explanation = f"[Błąd Claude API: {str(e)}]"
+    else:
+        explanation = "[Brak klucza ANTHROPIC_API_KEY — wyjaśnienie niedostępne]"
+
+    return CompareResponse(
+        shared_fake_probability=shared_fake_probability,
+        results=results,
+        explanation=explanation,
+    )

app/routes/misc.py

@@ -0,0 +1,68 @@
+"""
+Endpointy związane z obsługą dostępnych źródeł wiadomości oraz narzędziami deweloperskimi.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from fastapi import APIRouter, Query
+
+from ..config import NEWS_FEEDS
+from ..benchmark import run_benchmark, export_json, export_csv, _summary_only
+
+router = APIRouter()
+
+# Katalog, do którego endpoint zapisuje artefakty benchmarku
+_BENCHMARK_OUT = Path("benchmark_results")
+
+
+@router.get("/sources")
+def get_sources():
+    return list(NEWS_FEEDS.keys())
+
+
+@router.get("/benchmark")
+def benchmark(
+    adapters: Optional[str] = Query(
+        default=None,
+        description="Przecinkowa lista adapterów: roberta,xlm-roberta,norbert",
+    ),
+    langs: Optional[str] = Query(
+        default=None,
+        description="Przecinkowa lista języków: en,pl,no",
+    ),
+    save: bool = Query(
+        default=True,
+        description="Czy zapisać wyniki do JSON i CSV w katalogu benchmark_results/",
+    ),
+    full: bool = Query(
+        default=False,
+        description="Czy zwrócić szczegółowe wyniki per_text (domyślnie tylko podsumowanie)",
+    ),
+):
+    """
+    Uruchamia benchmark NLP i zwraca wyniki.
+
+    Czas odpowiedzi zależy od liczby adapterów i języków — może wynosić kilkadziesiąt sekund
+    przy pierwszym uruchomieniu (lazy-loading modeli HuggingFace).
+
+    Przykłady:
+    - GET /benchmark
+    - GET /benchmark?adapters=roberta,xlm-roberta&langs=en,pl
+    - GET /benchmark?full=true&save=false
+    """
+    adapter_names = [a.strip() for a in adapters.split(",")] if adapters else None
+    lang_list = [l.strip() for l in langs.split(",")] if langs else None
+
+    results = run_benchmark(adapter_names=adapter_names, langs=lang_list)
+
+    if save:
+        export_json(results, _BENCHMARK_OUT / "benchmark.json")
+        export_csv(results, _BENCHMARK_OUT / "benchmark.csv")
+
+    return {
+        "results": results if full else _summary_only(results),
+        "saved": save,
+        "output_dir": str(_BENCHMARK_OUT) if save else None,
+    }
+

app/routes/news.py

@@ -0,0 +1,266 @@
+"""
+Endpointy związane z pobieraniem, analizą i strumieniowaniem wiadomości.
+"""
+
+import asyncio
+import json
+from typing import List
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi_cache.decorator import cache
+
+from ..config import CACHE_TTL, NEWS_FEEDS
+from ..rss_utils import fetch_feed, clean_html, get_from_cache, set_to_cache, FeedFetchError
+from ..nlp_service import analyze_news, set_active_adapter
+
+router = APIRouter()
+
+
+@router.get("/news/{source}")
+def get_news(source: str, lang: str = "pl", model: str = "roberta"):
+    # Walidacja źródła
+    if source not in NEWS_FEEDS:
+        raise HTTPException(status_code=404, detail="Źródło nieobsługiwane")
+
+    # Ustawienie aktywnego adaptera NLP
+    try:
+        set_active_adapter(model)
+    except ValueError:
+        raise HTTPException(status_code=400, detail=f"Nieznany model: {model}")
+
+    url = NEWS_FEEDS[source]
+
+    # Pobranie RSS — FeedFetchError (404/timeout) zwraca pustą listę zamiast HTTP 500
+    try:
+        feed = fetch_feed(url)
+    except FeedFetchError as e:
+        print(f"⚠️  Feed niedostępny [{source}]: {e}")
+        return {"source": source, "articles": [], "error": str(e)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Błąd pobierania newsów: {str(e)}")
+
+    if not feed.entries:
+        return {"source": source, "articles": []}
+
+    MAX_ARTICLES = 5
+    articles: List[dict] = []
+
+    # Przetwarzanie i analiza artykułów
+    for entry in feed.entries[:MAX_ARTICLES]:
+        summary = clean_html(entry.get("summary", "Brak opisu"))
+        text_to_analyze = (summary or "").strip() or entry.get("title", "")
+        analysis = analyze_news(text_to_analyze, lang)
+
+        articles.append({
+            "title": entry.get("title", "Bez tytułu"),
+            "link": entry.get("link", ""),
+            "summary": summary,
+            "published": entry.get("published", "Brak daty"),
+            "source": source,
+            "model": model,
+            **analysis
+        })
+
+    return {"source": source, "articles": articles}
+
+
+# Strumieniowanie newsów przez SSE
+@router.get("/stream-news/{source}")
+async def stream_news(source: str, lang: str = "pl", model: str = "roberta"):
+    if source not in NEWS_FEEDS:
+        raise HTTPException(status_code=404, detail="Źródło nieobsługiwane")
+
+    # Walidacja i ustawienie adaptera przed uruchomieniem generatora
+    try:
+        set_active_adapter(model)
+    except ValueError:
+        raise HTTPException(status_code=400, detail=f"Nieznany model: {model}")
+
+    async def event_generator():
+        # Próba pobrania RSS z cache
+        try:
+            cached = get_from_cache(source)
+            if cached:
+                feed = cached
+            else:
+                feed = fetch_feed(NEWS_FEEDS[source])
+                set_to_cache(source, feed)
+        except FeedFetchError as e:
+            print(f"⚠️  Feed niedostępny [{source}]: {e}")
+            yield f"event: backend_error\ndata: {json.dumps({'message': str(e), 'status': e.status_code})}\n\n"
+            yield f"event: done\ndata: {json.dumps({'count': 0})}\n\n"
+            return
+        except Exception as e:
+            yield f"event: backend_error\ndata: {json.dumps({'message': str(e)})}\n\n"
+            yield f"event: done\ndata: {json.dumps({'count': 0})}\n\n"
+            return
+
+        entries = feed.entries or []
+        MAX_ARTICLES = 5
+        to_send = entries[:MAX_ARTICLES]
+
+        # Metadane dla klienta
+        yield f"event: meta\ndata: {json.dumps({'total': len(to_send)})}\n\n"
+
+        sent = 0
+        for entry in to_send:
+            summary = clean_html(entry.get("summary", "Brak opisu"))
+            text_to_analyze = (summary or "").strip() or entry.get("title", "")
+
+            # Analiza NLP uruchamiana w executorze (CPU-bound)
+            loop = asyncio.get_event_loop()
+            analysis = await loop.run_in_executor(
+                None, lambda: analyze_news(text_to_analyze, lang)
+            )
+
+            article = {
+                "title": entry.get("title", "Bez tytułu"),
+                "link": entry.get("link", ""),
+                "summary": summary,
+                "published": entry.get("published", "Brak daty"),
+                "source": source,
+                "model": model,
+                **analysis,
+            }
+
+            yield f"data: {json.dumps(article, ensure_ascii=False)}\n\n"
+            sent += 1
+            await asyncio.sleep(0.3)
+
+        yield f"event: done\ndata: {json.dumps({'count': sent})}\n\n"
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Content-Type": "text/event-stream",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Headers": "*",
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+@router.get("/api/charts/summary")
+@cache(expire=CACHE_TTL)
+async def get_charts_summary(lang: str = "pl"):
+    """
+    Szybkie statystyki zbiorcze dla wszystkich źródeł
+    (uproszczona analiza oparta na tytułach).
+    """
+    sources = [
+        "BBC", "CNN", "NYTimes", "Guardian", "AlJazeera",
+        "PolsatNews", "Money", "Bankier", "SpidersWeb", "GazetaPrawna"
+    ]
+
+    summary_data = {}
+
+    for source in sources:
+        if source not in NEWS_FEEDS:
+            continue
+
+        try:
+            feed = fetch_feed(NEWS_FEEDS[source])
+
+            if not feed.entries:
+                summary_data[source] = {
+                    "count": 0,
+                    "emotions": {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+                }
+                continue
+
+            # Analiza tylko kilku tytułów (szybko)
+            articles = feed.entries[:3]
+            emotion_counts = {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+
+            for entry in articles:
+                title = entry.get("title", "").lower()
+                if any(word in title for word in ["good", "positive", "gain", "up", "success", "dobry", "wzrost", "zysk"]):
+                    emotion_counts["Pozytywne"] += 1
+                elif any(word in title for word in ["bad", "negative", "fall", "down", "loss", "crisis", "zły", "spadek", "kryzys"]):
+                    emotion_counts["Negatywne"] += 1
+                else:
+                    emotion_counts["Neutralne"] += 1
+
+            summary_data[source] = {
+                "count": len(feed.entries),
+                "analyzed": len(articles),
+                "emotions": emotion_counts,
+                "latest_title": articles[0].get("title", "")[:50] if articles else ""
+            }
+
+        except Exception:
+            summary_data[source] = {
+                "count": 0,
+                "emotions": {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+            }
+
+    return {
+        "summary": summary_data,
+        "total_sources": len(summary_data),
+        "cache_ttl": CACHE_TTL
+    }
+
+
+@router.get("/emotion-stats/{source}")
+@cache(expire=CACHE_TTL)
+def get_emotion_stats(source: str, lang: str = "pl", model: str = "roberta"):
+    # Statystyki emocji dla jednego źródła
+    if source not in NEWS_FEEDS:
+        raise HTTPException(status_code=404, detail="Źródło nieobsługiwane")
+
+    try:
+        news_data = get_news(source, lang, model)
+        articles = news_data.get("articles", [])
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Błąd generowania statystyk: {str(e)}")
+
+    emotion_counts = {"Pozytywne": 0, "Negatywne": 0, "Neutralne": 0}
+
+    for article in articles:
+        sentiment = article.get("sentiment", "Neutralne")
+        if sentiment in emotion_counts:
+            emotion_counts[sentiment] += 1
+
+    total = len(articles)
+    emotion_percentages = {
+        emotion: (round((count / total) * 100, 2) if total > 0 else 0)
+        for emotion, count in emotion_counts.items()
+    }
+
+    return {
+        "source": source,
+        "total_articles": total,
+        "emotion_counts": emotion_counts,
+        "emotion_percentages": emotion_percentages
+    }
+
+
+@router.get("/charts-data")
+@cache(expire=CACHE_TTL)
+async def get_all_charts_data(lang: str = "pl"):
+    """
+    Kompatybilność ze starszym frontendem – agreguje dane ze wszystkich źródeł.
+    """
+    sources = [
+        "BBC", "CNN", "NYTimes", "Guardian", "AlJazeera",
+        "PolsatNews", "Money", "Bankier", "SpidersWeb", "GazetaPrawna"
+    ]
+
+    async def fetch_stats(source):
+        try:
+            return {source: await get_emotion_stats(source, lang)}
+        except Exception:
+            return {source: None}
+
+    tasks = [fetch_stats(source) for source in sources]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    all_data = {}
+    for result in results:
+        if isinstance(result, dict):
+            all_data.update(result)
+
+    return {"charts": all_data}

app/routes/saved.py

@@ -0,0 +1,34 @@
+"""
+Endpointy związane z zapisywaniem i zarządzaniem zapisanymi artykułami.
+"""
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ..storage import read_all, append_article, delete_by_title
+from ..models import Article
+
+router = APIRouter()
+
+
+@router.get("/saved-articles")
+def get_saved_articles():
+    # Zwraca listę wszystkich zapisanych artykułów
+    return read_all()
+
+
+@router.post("/save-article")
+def save_article(article: Article):
+    # Zapisuje nowy artykuł do magazynu danych
+    return append_article(article.dict())
+
+
+@router.delete("/delete-article")
+async def delete_article(request: Request):
+    # Usuwa artykuł na podstawie tytułu przekazanego w body requestu
+    data = await request.json()
+    title = data.get("title")
+
+    if not title:
+        raise HTTPException(status_code=400, detail="Brak pola 'title'")
+
+    return delete_by_title(title)

app/rss_utils.py

@@ -0,0 +1,70 @@
+"""
+Narzędzia pomocnicze do pobierania i przetwarzania kanałów RSS oraz cache w pamięci.
+"""
+
+import time
+import requests
+import feedparser
+from bs4 import BeautifulSoup
+from typing import Dict, Any
+
+from .config import CACHE_TTL_SECONDS
+
+# Prosty cache w pamięci (key -> (value, timestamp))
+_cache_data: Dict[str, tuple[Any, float]] = {}
+
+
+def clean_html(text: str) -> str:
+    # Usuwa znaczniki HTML z treści RSS
+    return BeautifulSoup(text or "", "html.parser").get_text()
+
+
+def get_from_cache(key: str):
+    # Pobiera dane z cache, jeśli nie przekroczyły TTL
+    entry = _cache_data.get(key)
+    if not entry:
+        return None
+
+    value, ts = entry
+    if time.time() - ts > CACHE_TTL_SECONDS:
+        del _cache_data[key]
+        return None
+
+    return value
+
+
+def set_to_cache(key: str, value):
+    # Zapisuje dane do cache wraz z timestampem
+    _cache_data[key] = (value, time.time())
+
+
+class FeedFetchError(Exception):
+    """Wyjątek rzucany gdy feed RSS jest niedostępny lub zwraca błąd HTTP."""
+    def __init__(self, url: str, status_code: int, message: str = ""):
+        self.url = url
+        self.status_code = status_code
+        super().__init__(message or f"Feed unavailable: HTTP {status_code} for {url}")
+
+
+def fetch_feed(url: str):
+    """
+    Pobiera i parsuje kanał RSS z ustawionym User-Agent.
+    Rzuca FeedFetchError jeśli serwer zwróci błąd HTTP (4xx/5xx),
+    co pozwala wywołującemu zwrócić pustą listę zamiast HTTP 500.
+    """
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        "Accept": "application/rss+xml, application/xml, text/xml, */*",
+    }
+    try:
+        resp = requests.get(url, timeout=7, headers=headers)
+    except requests.exceptions.Timeout:
+        raise FeedFetchError(url, 408, f"Timeout fetching feed: {url}")
+    except requests.exceptions.ConnectionError as e:
+        raise FeedFetchError(url, 503, f"Connection error for {url}: {e}")
+
+    if resp.status_code >= 400:
+        raise FeedFetchError(url, resp.status_code,
+                             f"HTTP {resp.status_code} for feed: {url}")
+
+    return feedparser.parse(resp.content)

app/storage.py

@@ -0,0 +1,60 @@
+"""
+Warstwa dostępu do danych dla zapisanych artykułów (plik JSON).
+"""
+
+import json
+import threading
+from fastapi import HTTPException
+
+from .config import SAVED_FILE
+
+# Blokada wątków dla operacji zapisu/odczytu
+_lock = threading.Lock()
+
+
+def ensure_file():
+    # Tworzy plik danych, jeśli nie istnieje
+    if not SAVED_FILE.exists():
+        SAVED_FILE.write_text("[]", encoding="utf-8")
+
+
+def read_all():
+    # Zwraca wszystkie zapisane artykuły
+    ensure_file()
+    try:
+        return json.loads(SAVED_FILE.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return []
+
+
+def append_article(article: dict):
+    # Dodaje nowy artykuł do pliku JSON
+    ensure_file()
+    try:
+        with _lock, open(SAVED_FILE, "r+", encoding="utf-8") as f:
+            data = json.load(f)
+            data.append(article)
+            f.seek(0)
+            json.dump(data, f, ensure_ascii=False, indent=4)
+
+        return {"message": "Artykuł zapisany pomyślnie."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+def delete_by_title(title: str):
+    # Usuwa artykuł na podstawie tytułu
+    ensure_file()
+    try:
+        with _lock, open(SAVED_FILE, "r+", encoding="utf-8") as f:
+            saved = json.load(f)
+            new_saved = [
+                a for a in saved if a.get("title") != title
+            ]
+            f.seek(0)
+            f.truncate()
+            json.dump(new_saved, f, ensure_ascii=False, indent=4)
+
+        return {"message": "Artykuł usunięty."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -0,0 +1,31 @@
+# Zależności backendu aplikacji TruthScan
+
+# Framework API i serwer ASGI
+fastapi==0.115.12
+uvicorn==0.34.3
+starlette==0.46.2
+
+# Walidacja danych i modele
+pydantic==2.11.7
+pydantic_core==2.33.2
+annotated-types==0.7.0
+typing-extensions>=4.12.2
+
+# Cache
+fastapi-cache2==0.2.2
+
+# NLP i uczenie maszynowe
+transformers==4.44.2
+tokenizers==0.19.1
+torch==2.3.1+cpu --find-links https://download.pytorch.org/whl/cpu
+
+# Przetwarzanie RSS i HTML
+feedparser==6.0.11
+beautifulsoup4==4.12.3
+requests==2.31.0
+
+# Konfiguracja środowiska
+python-dotenv==1.0.1
+
+# Claude API (Anthropic)
+anthropic==0.40.0