Add neo4j and cross article verification

.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//mnt/c/Users/pante/Desktop/**)",
+      "Bash(pip install *)"
+    ]
+  }
+}

.env.example

@@ -26,3 +26,10 @@ CORS_ORIGINS=http://localhost:3000
 
 # NewsAPI key — only needed for the demo notebook, not the main pipeline
 # NEWSAPI_KEY=your_key_here
+
+# Neo4j (optional — for persistent cross-article analysis)
+# Start with: docker run -p 7687:7687 -e NEO4J_AUTH=neo4j/password neo4j:community
+NEO4J_URI=bolt://localhost:7687
+NEO4J_USER=neo4j
+NEO4J_PASSWORD=password
+NEO4J_ENABLED=false

backend/config.py

@@ -66,6 +66,13 @@ TCS_THRESHOLDS = {
 }
 
 
+# Neo4j — optional persistent store for cross-article analysis
+NEO4J_URI = os.getenv("NEO4J_URI", "bolt://localhost:7687")
+NEO4J_USER = os.getenv("NEO4J_USER", "neo4j")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD", "password")
+NEO4J_ENABLED = os.getenv("NEO4J_ENABLED", "false").lower() == "true"
+
+
 # FastAPI settings
 API_TITLE = "TCS - Temporal Coherence Score API"
 API_VERSION = "0.1.0"

backend/main.py

@@ -9,6 +9,9 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from backend.config import API_TITLE, API_VERSION, CORS_ORIGINS
 from backend.routers import analyze, compare, health
+from backend.routers.articles import router as articles_router
+from backend.routers.batch import router as batch_router
+from backend.routers.upload import router as upload_router
 
 logging.basicConfig(
     level=logging.INFO,
@@ -38,6 +41,9 @@ app.add_middleware(
 app.include_router(health.router)
 app.include_router(analyze.router)
 app.include_router(compare.router)
+app.include_router(articles_router)
+app.include_router(batch_router)
+app.include_router(upload_router)
 
 
 @app.on_event("startup")

backend/pipeline/graph/base_store.py

@@ -0,0 +1,32 @@
+"""Abstract interface for Temporal Knowledge Graph storage backends."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from backend.pipeline.graph.models import TemporalFact
+
+
+class AbstractTKGStore(ABC):
+    """Interface for Temporal Knowledge Graph storage backends."""
+
+    @abstractmethod
+    def add_fact(self, fact: TemporalFact, article_id: str | None = None) -> None: ...
+
+    @abstractmethod
+    def add_facts(self, facts: list[TemporalFact], article_id: str | None = None) -> None: ...
+
+    @abstractmethod
+    def get_all_facts(self, article_id: str | None = None) -> list[TemporalFact]: ...
+
+    @abstractmethod
+    def get_facts_for_entity(self, entity_name: str) -> list[TemporalFact]: ...
+
+    @abstractmethod
+    def get_articles(self) -> list[dict]: ...
+
+    @abstractmethod
+    def delete_article(self, article_id: str) -> bool: ...
+
+    @abstractmethod
+    def summary(self) -> dict: ...

backend/pipeline/graph/factory.py

@@ -0,0 +1,28 @@
+"""Factory for creating TKG storage backends."""
+
+from __future__ import annotations
+
+import logging
+
+from backend.pipeline.graph.base_store import AbstractTKGStore
+
+logger = logging.getLogger(__name__)
+
+
+def create_persistent_store() -> AbstractTKGStore | None:
+    """Return a Neo4jTKGStore if NEO4J_ENABLED=true, otherwise None."""
+    from backend.config import NEO4J_ENABLED, NEO4J_PASSWORD, NEO4J_URI, NEO4J_USER
+
+    if not NEO4J_ENABLED:
+        logger.debug("NEO4J_ENABLED=false — persistent store disabled")
+        return None
+
+    from backend.pipeline.graph.neo4j_store import Neo4jTKGStore
+
+    try:
+        store = Neo4jTKGStore(NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD)
+        logger.info(f"Persistent Neo4j store created at {NEO4J_URI}")
+        return store
+    except Exception as exc:
+        logger.error(f"Failed to connect to Neo4j at {NEO4J_URI}: {exc}")
+        return None

backend/pipeline/graph/neo4j_store.py

@@ -0,0 +1,262 @@
+"""Persistent TKG storage using Neo4j Community Edition."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from backend.pipeline.graph.base_store import AbstractTKGStore
+from backend.pipeline.graph.models import (
+    Entity, EntityType, RelationType, TemporalExpression, TemporalFact,
+)
+from backend.pipeline.graph.store import _entity_id
+
+if TYPE_CHECKING:
+    from neo4j import Driver
+
+logger = logging.getLogger(__name__)
+
+# Fields returned by every fact-fetching query — defined once to avoid repetition
+_FACT_RETURN = """
+    s.entity_id  AS s_id,   s.text AS s_text,   s.entity_type AS s_type,   s.wikidata_id AS s_wikidata,
+    o.entity_id  AS o_id,   o.text AS o_text,   o.entity_type AS o_type,   o.wikidata_id AS o_wikidata,
+    r.relation        AS relation,
+    r.time_start_iso  AS time_start_iso,  r.time_start_str  AS time_start_str,
+    r.time_end_iso    AS time_end_iso,    r.time_end_str    AS time_end_str,
+    r.time_point_iso  AS time_point_iso,  r.time_point_str  AS time_point_str,
+    r.source_sentence_idx AS sentence_idx,
+    r.confidence AS confidence,
+    r.extractor  AS extractor
+"""
+
+
+class Neo4jTKGStore(AbstractTKGStore):
+    """Persistent TKG storage using Neo4j."""
+
+    def __init__(self, uri: str, user: str, password: str) -> None:
+        from neo4j import GraphDatabase
+        self._driver: Driver = GraphDatabase.driver(uri, auth=(user, password))
+        self._ensure_indexes()
+        logger.info(f"Neo4jTKGStore connected to {uri}")
+
+    def _ensure_indexes(self) -> None:
+        """Create indexes on first run so lookups on entity_id and article_id are fast."""
+        with self._driver.session() as session:
+            session.run("CREATE INDEX IF NOT EXISTS FOR (e:Entity) ON (e.entity_id)")
+            session.run("CREATE INDEX IF NOT EXISTS FOR (a:Article) ON (a.article_id)")
+
+    def close(self) -> None:
+        self._driver.close()
+
+    # ── Write ──
+
+    def add_fact(self, fact: TemporalFact, article_id: str | None = None) -> None:
+        """Store a fact as two Entity nodes + a TEMPORAL_RELATION edge."""
+        with self._driver.session() as session:
+            session.execute_write(self._create_fact_tx, fact, article_id)
+
+    @staticmethod
+    def _create_fact_tx(tx, fact: TemporalFact, article_id: str | None) -> None:
+        def to_iso(expr: TemporalExpression | None) -> str | None:
+            if expr and expr.normalized_date:
+                return expr.normalized_date.isoformat()
+            return None
+
+        def to_str(expr: TemporalExpression | None) -> str | None:
+            return expr.date_string if expr else None
+
+        params = {
+            "subj_id":      _entity_id(fact.subject),
+            "subj_text":    fact.subject.text,
+            "subj_type":    fact.subject.entity_type.value,
+            "subj_wikidata": fact.subject.wikidata_id,
+            "obj_id":       _entity_id(fact.object),
+            "obj_text":     fact.object.text,
+            "obj_type":     fact.object.entity_type.value,
+            "obj_wikidata": fact.object.wikidata_id,
+            "relation":         fact.predicate.value,
+            "time_start_iso":   to_iso(fact.time_start),
+            "time_start_str":   to_str(fact.time_start),
+            "time_end_iso":     to_iso(fact.time_end),
+            "time_end_str":     to_str(fact.time_end),
+            "time_point_iso":   to_iso(fact.time_point),
+            "time_point_str":   to_str(fact.time_point),
+            "sentence_idx":     fact.source_sentence_idx,
+            "confidence":       fact.extraction_confidence,
+            "extractor":        fact.extractor,
+            "article_id":       article_id,
+        }
+
+        # MERGE entity nodes so the same entity is never duplicated across articles
+        tx.run("""
+            MERGE (s:Entity {entity_id: $subj_id})
+            ON CREATE SET s.text = $subj_text, s.entity_type = $subj_type,
+                          s.wikidata_id = $subj_wikidata
+            MERGE (o:Entity {entity_id: $obj_id})
+            ON CREATE SET o.text = $obj_text, o.entity_type = $obj_type,
+                          o.wikidata_id = $obj_wikidata
+            CREATE (s)-[:TEMPORAL_RELATION {
+                relation:          $relation,
+                time_start_iso:    $time_start_iso,
+                time_start_str:    $time_start_str,
+                time_end_iso:      $time_end_iso,
+                time_end_str:      $time_end_str,
+                time_point_iso:    $time_point_iso,
+                time_point_str:    $time_point_str,
+                source_sentence_idx: $sentence_idx,
+                confidence:        $confidence,
+                extractor:         $extractor,
+                article_id:        $article_id
+            }]->(o)
+        """, **params)
+
+        if article_id:
+            tx.run("MERGE (a:Article {article_id: $article_id})", article_id=article_id)
+
+    def add_facts(self, facts: list[TemporalFact], article_id: str | None = None) -> None:
+        for fact in facts:
+            self.add_fact(fact, article_id)
+        logger.info(
+            f"Neo4jTKGStore: {len(facts)} facts written"
+            + (f" for article {article_id}" if article_id else "")
+        )
+
+    # ── Read ──
+
+    def get_all_facts(self, article_id: str | None = None) -> list[TemporalFact]:
+        """Retrieve facts, optionally filtered by article_id."""
+        if article_id:
+            query = f"""
+                MATCH (s:Entity)-[r:TEMPORAL_RELATION {{article_id: $article_id}}]->(o:Entity)
+                RETURN {_FACT_RETURN}
+            """
+            params: dict = {"article_id": article_id}
+        else:
+            query = f"""
+                MATCH (s:Entity)-[r:TEMPORAL_RELATION]->(o:Entity)
+                RETURN {_FACT_RETURN}
+            """
+            params = {}
+
+        with self._driver.session() as session:
+            result = session.run(query, **params)
+            return [_record_to_fact(r) for r in result]
+
+    def get_facts_for_entity(self, entity_name: str) -> list[TemporalFact]:
+        """All facts across ALL articles where the entity appears as subject or object."""
+        entity_id = entity_name.lower().strip()
+        query = f"""
+            MATCH (s:Entity)-[r:TEMPORAL_RELATION]->(o:Entity)
+            WHERE s.entity_id = $entity_id OR o.entity_id = $entity_id
+            RETURN {_FACT_RETURN}
+        """
+        with self._driver.session() as session:
+            result = session.run(query, entity_id=entity_id)
+            return [_record_to_fact(r) for r in result]
+
+    def get_articles(self) -> list[dict]:
+        """List all analyzed articles with their fact counts."""
+        with self._driver.session() as session:
+            result = session.run("""
+                MATCH (a:Article)
+                OPTIONAL MATCH ()-[r:TEMPORAL_RELATION {article_id: a.article_id}]->()
+                RETURN a.article_id  AS article_id,
+                       a.title       AS title,
+                       a.source      AS source,
+                       a.analyzed_at AS analyzed_at,
+                       count(r)      AS fact_count
+                ORDER BY a.analyzed_at DESC
+            """)
+            return [dict(record) for record in result]
+
+    def delete_article(self, article_id: str) -> bool:
+        """Delete an article node and all TEMPORAL_RELATION edges that belong to it."""
+        with self._driver.session() as session:
+            check = session.run(
+                "MATCH (a:Article {article_id: $id}) RETURN count(a) > 0 AS found",
+                id=article_id,
+            ).single()
+            if not (check and check["found"]):
+                return False
+            session.run(
+                "MATCH ()-[r:TEMPORAL_RELATION {article_id: $id}]->() DELETE r",
+                id=article_id,
+            )
+            session.run(
+                "MATCH (a:Article {article_id: $id}) DELETE a",
+                id=article_id,
+            )
+            return True
+
+    def summary(self) -> dict:
+        with self._driver.session() as session:
+            result = session.run("""
+                MATCH (e:Entity) WITH count(e) AS nodes
+                MATCH ()-[r:TEMPORAL_RELATION]->() WITH nodes, count(r) AS edges
+                OPTIONAL MATCH (a:Article) WITH nodes, edges, count(a) AS articles
+                RETURN nodes, edges, articles
+            """).single()
+            if result is None:
+                return {"nodes": 0, "edges": 0, "articles": 0}
+            return {
+                "nodes":    result["nodes"],
+                "edges":    result["edges"],
+                "articles": result["articles"],
+            }
+
+
+# ── Helpers ──
+
+def _record_to_fact(record) -> TemporalFact:
+    """Reconstruct a TemporalFact from a Neo4j query record."""
+
+    def parse_entity_type(val: str) -> EntityType:
+        try:
+            return EntityType(val)
+        except ValueError:
+            return EntityType.OTHER
+
+    def parse_relation_type(val: str) -> RelationType:
+        try:
+            return RelationType(val)
+        except ValueError:
+            return RelationType.GENERIC
+
+    def parse_temporal_expr(
+        iso: str | None, date_str: str | None
+    ) -> TemporalExpression | None:
+        if iso is None:
+            return None
+        try:
+            dt: datetime | None = datetime.fromisoformat(iso)
+        except (ValueError, TypeError):
+            dt = None
+        return TemporalExpression(raw_text=date_str or "", normalized_date=dt, date_string=date_str)
+
+    subject = Entity(
+        text=record["s_text"],
+        entity_type=parse_entity_type(record["s_type"]),
+        start_char=0,
+        end_char=0,
+        wikidata_id=record.get("s_wikidata"),
+    )
+    obj = Entity(
+        text=record["o_text"],
+        entity_type=parse_entity_type(record["o_type"]),
+        start_char=0,
+        end_char=0,
+        wikidata_id=record.get("o_wikidata"),
+    )
+
+    return TemporalFact(
+        subject=subject,
+        predicate=parse_relation_type(record["relation"]),
+        object=obj,
+        time_start=parse_temporal_expr(record.get("time_start_iso"), record.get("time_start_str")),
+        time_end=parse_temporal_expr(record.get("time_end_iso"), record.get("time_end_str")),
+        time_point=parse_temporal_expr(record.get("time_point_iso"), record.get("time_point_str")),
+        source_sentence_idx=record.get("sentence_idx") or 0,
+        extraction_confidence=record.get("confidence") or 1.0,
+        extractor=record.get("extractor") or "unknown",
+    )

backend/pipeline/graph/store.py

@@ -8,6 +8,7 @@ from typing import Optional
 
 import networkx as nx
 
+from backend.pipeline.graph.base_store import AbstractTKGStore
 from backend.pipeline.graph.models import (
     Entity, EntityType, RelationType, TemporalExpression, TemporalFact,
 )
@@ -15,7 +16,7 @@ from backend.pipeline.graph.models import (
 logger = logging.getLogger(__name__)
 
 
-class TemporalKnowledgeGraph:
+class TemporalKnowledgeGraph(AbstractTKGStore):
     """
     Graf temporal conform Cai et al. (2024): G = (E, R, T, F).
     Noduri = entitati, Muchii = relatii cu metadata temporala.
@@ -26,8 +27,8 @@ class TemporalKnowledgeGraph:
         self._facts: list[TemporalFact] = []
 
     # ── Adaugare ──
-    def add_fact(self, fact: TemporalFact) -> None:
-        """Adauga un TemporalFact ca nod+muchie in graf."""
+    def add_fact(self, fact: TemporalFact, article_id: str | None = None) -> None:
+        """Adauga un TemporalFact ca nod+muchie in graf. article_id ignorat (in-memory)."""
         subj_id = _entity_id(fact.subject)
         obj_id = _entity_id(fact.object)
 
@@ -40,9 +41,9 @@ class TemporalKnowledgeGraph:
         self._graph.add_edge(subj_id, obj_id, **edge_attrs)
         self._facts.append(fact)
 
-    def add_facts(self, facts: list[TemporalFact]) -> None:
+    def add_facts(self, facts: list[TemporalFact], article_id: str | None = None) -> None:
         for fact in facts:
-            self.add_fact(fact)
+            self.add_fact(fact, article_id)
         logger.info(f"TKG: {len(facts)} fapte adaugate. Noduri: {self.node_count}, Muchii: {self.edge_count}")
 
     # ── Interogare noduri ──
@@ -53,7 +54,8 @@ class TemporalKnowledgeGraph:
         return dict(self._graph.nodes.get(entity_id, {}))
 
     # ── Interogare fapte ──
-    def get_all_facts(self) -> list[TemporalFact]:
+    def get_all_facts(self, article_id: str | None = None) -> list[TemporalFact]:
+        # article_id ignored — in-memory store holds one article at a time
         return list(self._facts)
 
     def get_facts_for_entity(self, entity_name: str) -> list[TemporalFact]:
@@ -61,6 +63,14 @@ class TemporalKnowledgeGraph:
         entity_id = entity_name.lower().strip()
         return [f for f in self._facts if _entity_id(f.subject) == entity_id or _entity_id(f.object) == entity_id]
 
+    def get_articles(self) -> list[dict]:
+        # in-memory store has no persistence; articles are not tracked
+        return []
+
+    def delete_article(self, article_id: str) -> bool:
+        # in-memory store has no persistence
+        return False
+
     def get_edges_in_interval(self, t_start: datetime, t_end: datetime) -> list[dict]:
         """Muchiile active in intervalul [t_start, t_end]."""
         result = []

backend/pipeline/verification/cross_article.py

@@ -0,0 +1,159 @@
+"""C3c — Cross-article inconsistency detection using the persistent TKG store."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from difflib import SequenceMatcher
+from typing import Optional
+
+from backend.pipeline.graph.base_store import AbstractTKGStore
+from backend.pipeline.graph.models import (
+    Inconsistency, InconsistencyType, Severity, TemporalFact,
+)
+
+logger = logging.getLogger(__name__)
+
+SIMILARITY_THRESHOLD = 0.80
+
+
+class CrossArticleVerifier:
+    """Detects inconsistencies between facts in the current article and
+    previously analyzed articles stored in Neo4j."""
+
+    def __init__(self, persistent_store: AbstractTKGStore) -> None:
+        self.store = persistent_store
+
+    def verify(
+        self,
+        current_facts: list[TemporalFact],
+        current_article_id: str,
+    ) -> list[Inconsistency]:
+        """Compare current article facts against all stored facts for the same entities.
+
+        Call this BEFORE persisting the current article so stored results belong
+        exclusively to prior articles.
+        """
+        inconsistencies: list[Inconsistency] = []
+
+        for fact in current_facts:
+            entity_name = fact.subject.text.lower().strip()
+            stored_facts = self.store.get_facts_for_entity(entity_name)
+
+            # safety guard: skip any fact already tagged to this article
+            other_facts = [
+                f for f in stored_facts
+                if getattr(f, "article_id", None) != current_article_id
+            ]
+
+            for stored in other_facts:
+                # check 1: same relation + similar object + conflicting dates
+                if (
+                    fact.predicate == stored.predicate
+                    and _objects_similar(fact.object.text, stored.object.text)
+                ):
+                    conflict = _check_date_conflict(fact, stored)
+                    if conflict:
+                        inconsistencies.append(conflict)
+
+                # check 2: same entity holds different positions at overlapping times
+                if (
+                    fact.predicate.value == "holds_position"
+                    and stored.predicate.value == "holds_position"
+                    and _overlapping_time(fact, stored)
+                    and not _objects_similar(fact.object.text, stored.object.text)
+                ):
+                    inconsistencies.append(
+                        Inconsistency(
+                            inconsistency_type=InconsistencyType.DATE_MISMATCH,
+                            severity=Severity.HIGH,
+                            description=(
+                                f"Cross-article conflict: '{fact.subject.text}' holds "
+                                f"different positions at overlapping times: "
+                                f"'{fact.object.text}' vs '{stored.object.text}'"
+                            ),
+                            facts_involved=[fact, stored],
+                            sentence_indices=[fact.source_sentence_idx],
+                            verified_by="cross_article",
+                            evidence=f"Article {current_article_id} vs stored facts",
+                        )
+                    )
+
+        logger.info(
+            f"Cross-article verification: {len(inconsistencies)} conflicts found "
+            f"for article {current_article_id}"
+        )
+        return inconsistencies
+
+
+def _objects_similar(a: str, b: str) -> bool:
+    """True when strings are equal (case-insensitive) or fuzzy-match above threshold."""
+    a_norm, b_norm = a.lower().strip(), b.lower().strip()
+    if a_norm == b_norm:
+        return True
+    return SequenceMatcher(None, a_norm, b_norm).ratio() >= SIMILARITY_THRESHOLD
+
+
+def _check_date_conflict(
+    fact_a: TemporalFact, fact_b: TemporalFact
+) -> Optional[Inconsistency]:
+    """Return an Inconsistency when the same claim appears with dates more than 1 year apart."""
+    time_a = _best_date(fact_a)
+    time_b = _best_date(fact_b)
+    if time_a is None or time_b is None:
+        return None
+
+    if abs((time_a - time_b).days) <= 365:
+        return None
+
+    return Inconsistency(
+        inconsistency_type=InconsistencyType.DATE_MISMATCH,
+        severity=Severity.MEDIUM,
+        description=(
+            f"Cross-article date conflict: '{fact_a.subject.text} "
+            f"{fact_a.predicate.value} {fact_a.object.text}' — "
+            f"{time_a.year} (current article) vs {time_b.year} (stored)"
+        ),
+        facts_involved=[fact_a, fact_b],
+        sentence_indices=[fact_a.source_sentence_idx],
+        verified_by="cross_article",
+        evidence=f"{time_a.date()} (current) vs {time_b.date()} (stored)",
+    )
+
+
+def _overlapping_time(fact_a: TemporalFact, fact_b: TemporalFact) -> bool:
+    """True if the temporal ranges of the two facts overlap."""
+    start_a = _range_start(fact_a)
+    start_b = _range_start(fact_b)
+    if start_a is None or start_b is None:
+        return False
+
+    end_a = _range_end(fact_a) or datetime.max
+    end_b = _range_end(fact_b) or datetime.max
+
+    return start_a <= end_b and start_b <= end_a
+
+
+def _best_date(fact: TemporalFact) -> Optional[datetime]:
+    """Most representative single datetime: time_point > time_start > time_end."""
+    for attr in ("time_point", "time_start", "time_end"):
+        expr = getattr(fact, attr)
+        if expr and expr.normalized_date:
+            return expr.normalized_date
+    return None
+
+
+def _range_start(fact: TemporalFact) -> Optional[datetime]:
+    for attr in ("time_start", "time_point"):
+        expr = getattr(fact, attr)
+        if expr and expr.normalized_date:
+            return expr.normalized_date
+    return None
+
+
+def _range_end(fact: TemporalFact) -> Optional[datetime]:
+    for attr in ("time_end", "time_point"):
+        expr = getattr(fact, attr)
+        if expr and expr.normalized_date:
+            return expr.normalized_date
+    return None

backend/routers/analyze.py

@@ -3,13 +3,14 @@
 from __future__ import annotations
 
 import logging
+import uuid
 from datetime import datetime
 from typing import Optional
 
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from backend.pipeline.graph.models import Article
+from backend.pipeline.graph.models import Article, Inconsistency
 from backend.pipeline.orchestrator import PipelineOrchestrator
 from backend.routers.dependencies import get_orchestrator, explainer
 
@@ -26,6 +27,7 @@ class AnalyzeRequest(BaseModel):
     source: str = Field(default="", description="Sursa articolului")
     pipeline: str = Field(default="spacy", description="Pipeline: 'spacy' sau 'llm'")
     model: Optional[str] = Field(default=None, description="Model specific: en_core_web_trf, llama3, mistral, etc. None = default per pipeline")
+    persist: bool = Field(default=False, description="Save facts to Neo4j for cross-article analysis")
 
 
 class InconsistencyResponse(BaseModel):
@@ -65,11 +67,26 @@ class AnalyzeResponse(BaseModel):
     pipeline: str
     model: str = Field(default="", description="Model folosit")
     processing_time_ms: float
+    article_id: Optional[str] = Field(default=None, description="Neo4j article ID (set when persist=True)")
+    cross_article_inconsistencies: list[InconsistencyResponse] = Field(default_factory=list)
 
 
 _explainer = explainer
 
 
+def _to_inconsistency_response(inc: Inconsistency) -> InconsistencyResponse:
+    """Serialize an Inconsistency dataclass to the API response model."""
+    return InconsistencyResponse(
+        type=inc.inconsistency_type.value,
+        severity=inc.severity.value,
+        severity_label=inc.severity.value.title(),
+        description=inc.description,
+        evidence=inc.evidence,
+        verified_by=inc.verified_by,
+        sentence_indices=inc.sentence_indices,
+    )
+
+
 # Endpoint
 @router.post("/analyze", response_model=AnalyzeResponse)
 async def analyze_article(req: AnalyzeRequest) -> AnalyzeResponse:
@@ -108,6 +125,37 @@ async def analyze_article(req: AnalyzeRequest) -> AnalyzeResponse:
         logger.error(f"/analyze: eroare pipeline — {e}", exc_info=True)
         raise HTTPException(status_code=500, detail="Eroare interna la procesare.")
 
+    # optional: persist to Neo4j and run cross-article verification
+    article_id: Optional[str] = None
+    cross_article_inconsistencies: list[InconsistencyResponse] = []
+
+    if req.persist:
+        from backend.config import NEO4J_ENABLED
+        if NEO4J_ENABLED:
+            from backend.pipeline.graph.factory import create_persistent_store
+            from backend.pipeline.verification.cross_article import CrossArticleVerifier
+
+            article_id = str(uuid.uuid4())
+            store = create_persistent_store()
+            if store is not None:
+                try:
+                    verifier = CrossArticleVerifier(store)
+                    cross_incs = verifier.verify(result.facts, article_id)
+                    store.add_facts(result.facts, article_id=article_id)
+                    cross_article_inconsistencies = [
+                        _to_inconsistency_response(c) for c in cross_incs
+                    ]
+                    logger.info(
+                        f"/analyze: persisted {len(result.facts)} facts as {article_id}, "
+                        f"{len(cross_incs)} cross-article conflicts"
+                    )
+                except Exception as e:
+                    logger.error(f"/analyze: persistence error — {e}", exc_info=True)
+                finally:
+                    store.close()
+        else:
+            logger.warning("/analyze: persist=True but NEO4J_ENABLED=false — skipping")
+
     # Genereaza explicatii structurate
     explanation = _explainer.explain_structured(result)
 
@@ -124,4 +172,6 @@ async def analyze_article(req: AnalyzeRequest) -> AnalyzeResponse:
         pipeline=result.pipeline_variant,
         model=req.model or AVAILABLE_MODELS[req.pipeline]["default"],
         processing_time_ms=result.processing_time_ms,
+        article_id=article_id,
+        cross_article_inconsistencies=cross_article_inconsistencies,
     )

backend/routers/articles.py

@@ -0,0 +1,50 @@
+"""Router — GET /articles, DELETE /articles/{article_id}: article management via Neo4j."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter, HTTPException
+
+from backend.pipeline.graph.factory import create_persistent_store
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["articles"])
+
+
+@router.get("/articles")
+async def list_articles():
+    """List all previously analyzed articles stored in Neo4j."""
+    store = create_persistent_store()
+    if store is None:
+        return {"articles": [], "neo4j_enabled": False}
+    try:
+        articles = store.get_articles()
+        return {"articles": articles, "neo4j_enabled": True}
+    except Exception as e:
+        logger.error(f"GET /articles error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Failed to retrieve articles from Neo4j.")
+    finally:
+        store.close()
+
+
+@router.delete("/articles/{article_id}")
+async def delete_article(article_id: str):
+    """Delete an article and all its facts from Neo4j."""
+    store = create_persistent_store()
+    if store is None:
+        raise HTTPException(status_code=503, detail="Neo4j not enabled.")
+    try:
+        deleted = store.delete_article(article_id)
+        if not deleted:
+            raise HTTPException(
+                status_code=404, detail=f"Article '{article_id}' not found."
+            )
+        return {"deleted": True, "article_id": article_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"DELETE /articles/{article_id} error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Failed to delete article from Neo4j.")
+    finally:
+        store.close()

backend/routers/batch.py

@@ -0,0 +1,185 @@
+"""Router — POST /analyze-batch: analyze multiple articles with optional Neo4j persistence."""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from backend.pipeline.graph.models import Article
+from backend.routers.analyze import InconsistencyResponse, _to_inconsistency_response
+from backend.routers.dependencies import explainer, get_orchestrator
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["batch"])
+
+
+class BatchArticle(BaseModel):
+    text: str = Field(..., min_length=20)
+    title: str = Field(default="")
+    publication_date: Optional[str] = None
+    source: str = Field(default="")
+
+
+class BatchRequest(BaseModel):
+    articles: list[BatchArticle] = Field(..., min_length=1, max_length=50)
+    pipeline: str = Field(default="spacy")
+    model: Optional[str] = None
+    persist: bool = Field(
+        default=True,
+        description="Save to Neo4j for cross-article analysis",
+    )
+
+
+class BatchArticleResult(BaseModel):
+    article_id: str
+    title: str
+    score: float
+    label: str
+    summary: str
+    n_claims: int
+    n_inconsistencies: int
+    n_cross_article_inconsistencies: int
+    cross_article_conflicts: list[InconsistencyResponse]
+    processing_time_ms: float
+    error: Optional[str] = None
+
+
+class BatchResponse(BaseModel):
+    results: list[BatchArticleResult]
+    total_articles: int
+    total_cross_article_conflicts: int
+    avg_score: float
+    neo4j_enabled: bool
+    persisted: bool
+
+
+@router.post("/analyze-batch", response_model=BatchResponse)
+async def analyze_batch(req: BatchRequest) -> BatchResponse:
+    """Analyze multiple articles. Persist to Neo4j and run cross-article verification when enabled."""
+    from backend.config import AVAILABLE_MODELS, NEO4J_ENABLED
+
+    if req.pipeline not in ("spacy", "llm"):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unknown pipeline '{req.pipeline}'. Options: 'spacy', 'llm'.",
+        )
+    if req.model:
+        available = AVAILABLE_MODELS.get(req.pipeline, {}).get("models", [])
+        if req.model not in available:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Model '{req.model}' not available for pipeline '{req.pipeline}'. Options: {available}",
+            )
+
+    persist = req.persist and NEO4J_ENABLED
+
+    # open one shared store connection for the whole batch
+    store = None
+    if persist:
+        from backend.pipeline.graph.factory import create_persistent_store
+        store = create_persistent_store()
+        if store is None:
+            persist = False
+
+    results: list[BatchArticleResult] = []
+    total_cross_conflicts = 0
+
+    try:
+        for batch_article in req.articles:
+            article_id = str(uuid.uuid4())
+
+            pub_date: Optional[datetime] = None
+            if batch_article.publication_date:
+                try:
+                    pub_date = datetime.strptime(batch_article.publication_date, "%Y-%m-%d")
+                except ValueError:
+                    pass
+
+            article = Article(
+                text=batch_article.text,
+                title=batch_article.title,
+                publication_date=pub_date,
+                source=batch_article.source,
+            )
+
+            try:
+                orchestrator = get_orchestrator(req.pipeline, req.model)
+                result = orchestrator.run(article)
+            except Exception as e:
+                logger.error(
+                    f"/analyze-batch: pipeline error on '{batch_article.title}': {e}",
+                    exc_info=True,
+                )
+                results.append(
+                    BatchArticleResult(
+                        article_id=article_id,
+                        title=batch_article.title,
+                        score=0.0,
+                        label="Error",
+                        summary="Pipeline error — see server logs.",
+                        n_claims=0,
+                        n_inconsistencies=0,
+                        n_cross_article_inconsistencies=0,
+                        cross_article_conflicts=[],
+                        processing_time_ms=0.0,
+                        error=str(e)[:300],
+                    )
+                )
+                continue
+
+            explanation = explainer.explain_structured(result)
+
+            cross_conflicts: list[InconsistencyResponse] = []
+            if store is not None:
+                from backend.pipeline.verification.cross_article import CrossArticleVerifier
+
+                try:
+                    # verify BEFORE persisting so current article is not in the store yet
+                    verifier = CrossArticleVerifier(store)
+                    raw_conflicts = verifier.verify(result.facts, article_id)
+                    store.add_facts(result.facts, article_id=article_id)
+                    cross_conflicts = [_to_inconsistency_response(c) for c in raw_conflicts]
+                    total_cross_conflicts += len(cross_conflicts)
+                except Exception as e:
+                    logger.error(
+                        f"/analyze-batch: persistence error for {article_id}: {e}",
+                        exc_info=True,
+                    )
+
+            results.append(
+                BatchArticleResult(
+                    article_id=article_id,
+                    title=batch_article.title,
+                    score=result.score,
+                    label=result.label,
+                    summary=explanation["summary"],
+                    n_claims=result.n_temporal_claims,
+                    n_inconsistencies=result.n_inconsistencies,
+                    n_cross_article_inconsistencies=len(cross_conflicts),
+                    cross_article_conflicts=cross_conflicts,
+                    processing_time_ms=result.processing_time_ms,
+                )
+            )
+    finally:
+        if store is not None:
+            store.close()
+
+    successful = [r for r in results if r.error is None]
+    avg_score = (
+        round(sum(r.score for r in successful) / len(successful), 4)
+        if successful else 0.0
+    )
+
+    return BatchResponse(
+        results=results,
+        total_articles=len(results),
+        total_cross_article_conflicts=total_cross_conflicts,
+        avg_score=avg_score,
+        neo4j_enabled=NEO4J_ENABLED,
+        persisted=persist,
+    )

backend/routers/upload.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+
+router = APIRouter(tags=["upload"])
+
+
+@router.post("/upload")
+async def upload_file(file: UploadFile = File(...)) -> dict:
+    """Extract text from an uploaded file (.txt, .pdf, .docx)."""
+    filename = file.filename or ""
+    ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
+    content = await file.read()
+
+    if ext == "txt":
+        text = content.decode("utf-8", errors="replace")
+
+    elif ext == "pdf":
+        from PyPDF2 import PdfReader
+        import io
+        reader = PdfReader(io.BytesIO(content))
+        text = "\n\n".join(page.extract_text() or "" for page in reader.pages)
+
+    elif ext in ("docx", "doc"):
+        from docx import Document
+        import io
+        doc = Document(io.BytesIO(content))
+        text = "\n\n".join(p.text for p in doc.paragraphs if p.text.strip())
+
+    else:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported file type: .{ext}. Use .txt, .pdf, or .docx",
+        )
+
+    if not text.strip():
+        raise HTTPException(status_code=400, detail="No text could be extracted from the file")
+
+    return {
+        "text": text.strip(),
+        "filename": filename,
+        "file_type": ext,
+        "char_count": len(text.strip()),
+    }

frontend/src/App.tsx

@@ -3,13 +3,19 @@ import {
   AppBar,
   Box,
   Container,
+  IconButton,
   Tab,
   Tabs,
   Toolbar,
+  Tooltip,
   Typography,
 } from "@mui/material";
-import { checkHealth } from "./api/client";
+import { History } from "@mui/icons-material";
+import { checkHealth, getModels } from "./api/client";
+import type { ModelsResponse } from "./types";
 import AnalyzeTab from "./components/AnalyzeTab";
+import ArticleHistory from "./components/ArticleHistory";
+import BatchTab from "./components/BatchTab";
 import CompareTab from "./components/CompareTab";
 
 type HealthStatus = "checking" | "ok" | "error";
@@ -17,6 +23,8 @@ type HealthStatus = "checking" | "ok" | "error";
 function App(): React.ReactElement {
   const [activeTab, setActiveTab] = useState<number>(0);
   const [healthStatus, setHealthStatus] = useState<HealthStatus>("checking");
+  const [availableModels, setAvailableModels] = useState<ModelsResponse | undefined>(undefined);
+  const [historyOpen, setHistoryOpen] = useState<boolean>(false);
 
   useEffect(() => {
     checkHealth()
@@ -24,6 +32,12 @@ function App(): React.ReactElement {
       .catch(() => setHealthStatus("error"));
   }, []);
 
+  useEffect(() => {
+    getModels()
+      .then(setAvailableModels)
+      .catch(() => undefined);
+  }, []);
+
   const healthColor: string =
     healthStatus === "ok" ? "#22c55e" : healthStatus === "error" ? "#ef4444" : "#94a3b8";
 
@@ -61,19 +75,31 @@ function App(): React.ReactElement {
             </Typography>
           </Box>
 
-          <Box sx={{ display: "flex", alignItems: "center", gap: 0.75 }}>
-            <Box
-              sx={{
-                width: 8,
-                height: 8,
-                borderRadius: "50%",
-                bgcolor: healthColor,
-                flexShrink: 0,
-              }}
-            />
-            <Typography variant="caption" color="text.secondary">
-              {healthLabel}
-            </Typography>
+          <Box sx={{ display: "flex", alignItems: "center", gap: 1.5 }}>
+            <Box sx={{ display: "flex", alignItems: "center", gap: 0.75 }}>
+              <Box
+                sx={{
+                  width: 8,
+                  height: 8,
+                  borderRadius: "50%",
+                  bgcolor: healthColor,
+                  flexShrink: 0,
+                }}
+              />
+              <Typography variant="caption" color="text.secondary">
+                {healthLabel}
+              </Typography>
+            </Box>
+
+            <Tooltip title="Article history (Neo4j)">
+              <IconButton
+                size="small"
+                onClick={() => setHistoryOpen(true)}
+                aria-label="Open article history"
+              >
+                <History fontSize="small" />
+              </IconButton>
+            </Tooltip>
           </Box>
         </Toolbar>
       </AppBar>
@@ -92,6 +118,7 @@ function App(): React.ReactElement {
           >
             <Tab label="Analyze" />
             <Tab label="Compare" />
+            <Tab label="Batch" />
           </Tabs>
         </Container>
       </Box>
@@ -100,6 +127,7 @@ function App(): React.ReactElement {
         <Container maxWidth="lg" sx={{ py: 3 }}>
           {activeTab === 0 && <AnalyzeTab />}
           {activeTab === 1 && <CompareTab />}
+          {activeTab === 2 && <BatchTab availableModels={availableModels} />}
         </Container>
       </Box>
 
@@ -115,6 +143,8 @@ function App(): React.ReactElement {
           Bachelor Thesis — UTCN 2026 — Marius Pantea
         </Typography>
       </Box>
+
+      <ArticleHistory open={historyOpen} onClose={() => setHistoryOpen(false)} />
     </Box>
   );
 }

frontend/src/api/client.ts

@@ -1,7 +1,13 @@
 /* client.ts — Axios instance and typed API functions */
 
 import axios from "axios";
-import type { AnalyzeRequest, AnalyzeResponse, CompareRequest, CompareResponse, HealthResponse, ModelsResponse } from "../types";
+import type {
+  AnalyzeRequest, AnalyzeResponse,
+  ArticlesResponse,
+  BatchRequest, BatchResponse,
+  CompareRequest, CompareResponse,
+  HealthResponse, ModelsResponse,
+} from "../types";
 
 // axios instance
 const apiClient = axios.create({
@@ -33,4 +39,35 @@ export async function getModels(): Promise<ModelsResponse> {
   return data;
 }
 
+export async function analyzeBatch(req: BatchRequest): Promise<BatchResponse> {
+  const { data } = await apiClient.post<BatchResponse>("/analyze-batch", req);
+  return data;
+}
+
+export async function getArticles(): Promise<ArticlesResponse> {
+  const { data } = await apiClient.get<ArticlesResponse>("/articles");
+  return data;
+}
+
+export async function deleteArticle(articleId: string): Promise<void> {
+  await apiClient.delete(`/articles/${encodeURIComponent(articleId)}`);
+}
+
+export interface UploadResponse {
+  text: string;
+  filename: string;
+  file_type: string;
+  char_count: number;
+}
+
+export async function uploadFile(file: File): Promise<UploadResponse> {
+  const formData = new FormData();
+  formData.append("file", file);
+  const { data } = await apiClient.post<UploadResponse>("/upload", formData, {
+    headers: { "Content-Type": "multipart/form-data" },
+    timeout: 30_000,
+  });
+  return data;
+}
+
 export default apiClient;

frontend/src/components/AnalyzeTab.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useState } from "react";
-import { Alert, Stack } from "@mui/material";
+import { Alert, Box, Checkbox, Chip, FormControlLabel, Stack, Typography } from "@mui/material";
 import axios from "axios";
 import type { AnalyzeRequest, AnalyzeResponse, ModelsResponse } from "../types";
 import { analyzeArticle, getModels } from "../api/client";
@@ -16,6 +16,7 @@ function AnalyzeTab(): React.ReactElement {
   const [isLoading, setIsLoading] = useState<boolean>(false);
   const [error, setError] = useState<string | null>(null);
   const [availableModels, setAvailableModels] = useState<ModelsResponse | undefined>(undefined);
+  const [persist, setPersist] = useState<boolean>(false);
 
   useEffect(() => {
     getModels()
@@ -28,7 +29,7 @@ function AnalyzeTab(): React.ReactElement {
     setError(null);
     setArticleText(request.text);
     try {
-      const result = await analyzeArticle(request);
+      const result = await analyzeArticle({ ...request, persist });
       setAnalyzeResult(result);
     } catch (err: unknown) {
       if (axios.isAxiosError(err)) {
@@ -44,6 +45,8 @@ function AnalyzeTab(): React.ReactElement {
     }
   };
 
+  const crossArticleConflicts = analyzeResult?.cross_article_inconsistencies ?? [];
+
   return (
     <Stack spacing={3}>
       <ArticleInput
@@ -53,6 +56,22 @@ function AnalyzeTab(): React.ReactElement {
         availableModels={availableModels}
       />
 
+      <FormControlLabel
+        sx={{ mt: -1 }}
+        control={
+          <Checkbox
+            size="small"
+            checked={persist}
+            onChange={(e) => setPersist(e.target.checked)}
+          />
+        }
+        label={
+          <Typography variant="body2">
+            Save to Neo4j for cross-article analysis
+          </Typography>
+        }
+      />
+
       {error && (
         <Alert severity="error" onClose={() => setError(null)}>
           {error}
@@ -72,6 +91,44 @@ function AnalyzeTab(): React.ReactElement {
             model={analyzeResult.model}
             processingTimeMs={analyzeResult.processing_time_ms}
           />
+
+          {/* Cross-article conflicts banner */}
+          {crossArticleConflicts.length > 0 && (
+            <Alert
+              severity="warning"
+              action={
+                <Chip
+                  label={`${crossArticleConflicts.length} conflict${crossArticleConflicts.length !== 1 ? "s" : ""}`}
+                  size="small"
+                  color="warning"
+                />
+              }
+            >
+              <Box>
+                <Typography variant="body2" sx={{ fontWeight: "medium", mb: 0.5 }}>
+                  Cross-article conflicts detected
+                </Typography>
+                {crossArticleConflicts.map((c, i) => (
+                  <Typography key={i} variant="caption" sx={{ display: "block" }}>
+                    • {c.description}
+                  </Typography>
+                ))}
+                {analyzeResult.article_id && (
+                  <Typography variant="caption" color="text.secondary" sx={{ mt: 0.5, display: "block" }}>
+                    Saved as {analyzeResult.article_id}
+                  </Typography>
+                )}
+              </Box>
+            </Alert>
+          )}
+
+          {/* Saved without conflicts */}
+          {analyzeResult.article_id && crossArticleConflicts.length === 0 && (
+            <Alert severity="success" sx={{ py: 0.5 }}>
+              Saved to Neo4j — no cross-article conflicts found.
+            </Alert>
+          )}
+
           <TextHighlight
             text={articleText}
             annotations={analyzeResult.fact_annotations}

frontend/src/components/ArticleHistory.tsx

@@ -0,0 +1,213 @@
+import React, { useCallback, useEffect, useState } from "react";
+import {
+  Alert,
+  Box,
+  CircularProgress,
+  Divider,
+  Drawer,
+  IconButton,
+  List,
+  ListItem,
+  ListItemSecondaryAction,
+  ListItemText,
+  Tooltip,
+  Typography,
+} from "@mui/material";
+import { Close, Delete } from "@mui/icons-material";
+import type { StoredArticle } from "../types";
+import { deleteArticle, getArticles } from "../api/client";
+
+interface ArticleHistoryProps {
+  open: boolean;
+  onClose: () => void;
+}
+
+function ArticleHistory({ open, onClose }: ArticleHistoryProps): React.ReactElement {
+  const [articles, setArticles] = useState<StoredArticle[]>([]);
+  const [neo4jEnabled, setNeo4jEnabled] = useState<boolean>(true);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [deletingId, setDeletingId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchArticles = useCallback(async (): Promise<void> => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await getArticles();
+      setNeo4jEnabled(response.neo4j_enabled);
+      setArticles(response.articles);
+    } catch {
+      setError("Failed to load article history.");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (open) {
+      void fetchArticles();
+    }
+  }, [open, fetchArticles]);
+
+  const handleDelete = async (articleId: string): Promise<void> => {
+    setDeletingId(articleId);
+    setError(null);
+    try {
+      await deleteArticle(articleId);
+      setArticles((prev) => prev.filter((a) => a.article_id !== articleId));
+    } catch {
+      setError(`Failed to delete article ${articleId}.`);
+    } finally {
+      setDeletingId(null);
+    }
+  };
+
+  const formatDate = (raw: string | null): string => {
+    if (!raw) return "Unknown date";
+    try {
+      return new Date(raw).toLocaleDateString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+      });
+    } catch {
+      return raw;
+    }
+  };
+
+  return (
+    <Drawer
+      anchor="right"
+      open={open}
+      onClose={onClose}
+      slotProps={{ paper: { sx: { width: 350, display: "flex", flexDirection: "column" } } }}
+    >
+      {/* Header */}
+      <Box
+        sx={{
+          px: 2,
+          py: 1.5,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "space-between",
+          borderBottom: "1px solid",
+          borderColor: "divider",
+          flexShrink: 0,
+        }}
+      >
+        <Typography variant="subtitle1" sx={{ fontWeight: "medium" }}>
+          Article History
+        </Typography>
+        <IconButton size="small" onClick={onClose} aria-label="Close history">
+          <Close fontSize="small" />
+        </IconButton>
+      </Box>
+
+      {/* Body */}
+      <Box sx={{ flex: 1, overflowY: "auto", px: 0 }}>
+        {!neo4jEnabled && (
+          <Box sx={{ p: 2 }}>
+            <Alert severity="info">
+              Neo4j not configured. Enable in <code>.env</code> to save articles.
+            </Alert>
+          </Box>
+        )}
+
+        {neo4jEnabled && isLoading && (
+          <Box sx={{ display: "flex", justifyContent: "center", pt: 4 }}>
+            <CircularProgress size={28} />
+          </Box>
+        )}
+
+        {neo4jEnabled && error && (
+          <Box sx={{ p: 2 }}>
+            <Alert severity="error" onClose={() => setError(null)}>
+              {error}
+            </Alert>
+          </Box>
+        )}
+
+        {neo4jEnabled && !isLoading && articles.length === 0 && !error && (
+          <Box sx={{ p: 2, textAlign: "center" }}>
+            <Typography variant="body2" color="text.secondary">
+              No articles saved yet. Use{" "}
+              <strong>Save to Neo4j</strong> when analyzing to store results.
+            </Typography>
+          </Box>
+        )}
+
+        {neo4jEnabled && !isLoading && articles.length > 0 && (
+          <List dense disablePadding>
+            {articles.map((article, idx) => (
+              <React.Fragment key={article.article_id}>
+                <ListItem
+                  alignItems="flex-start"
+                  sx={{ pr: 6 }}
+                >
+                  <ListItemText
+                    primary={
+                      <Typography variant="body2" noWrap sx={{ fontWeight: "medium" }}>
+                        {article.title ?? <em>Untitled</em>}
+                      </Typography>
+                    }
+                    secondary={
+                      <Box component="span" sx={{ display: "flex", flexDirection: "column", gap: 0.25 }}>
+                        {article.source && (
+                          <Typography variant="caption" color="text.secondary" noWrap>
+                            {article.source}
+                          </Typography>
+                        )}
+                        <Typography variant="caption" color="text.secondary">
+                          {formatDate(article.analyzed_at)} · {article.fact_count} facts
+                        </Typography>
+                      </Box>
+                    }
+                  />
+                  <ListItemSecondaryAction>
+                    <Tooltip title="Delete article">
+                      <span>
+                        <IconButton
+                          size="small"
+                          edge="end"
+                          onClick={() => void handleDelete(article.article_id)}
+                          disabled={deletingId === article.article_id}
+                          aria-label="Delete article"
+                        >
+                          {deletingId === article.article_id ? (
+                            <CircularProgress size={16} />
+                          ) : (
+                            <Delete fontSize="small" />
+                          )}
+                        </IconButton>
+                      </span>
+                    </Tooltip>
+                  </ListItemSecondaryAction>
+                </ListItem>
+                {idx < articles.length - 1 && <Divider component="li" />}
+              </React.Fragment>
+            ))}
+          </List>
+        )}
+      </Box>
+
+      {/* Footer */}
+      {neo4jEnabled && articles.length > 0 && (
+        <Box
+          sx={{
+            px: 2,
+            py: 1,
+            borderTop: "1px solid",
+            borderColor: "divider",
+            flexShrink: 0,
+          }}
+        >
+          <Typography variant="caption" color="text.secondary">
+            {articles.length} article{articles.length !== 1 ? "s" : ""} stored
+          </Typography>
+        </Box>
+      )}
+    </Drawer>
+  );
+}
+
+export default ArticleHistory;

frontend/src/components/ArticleInput.tsx

@@ -5,6 +5,7 @@ import {
   AccordionSummary,
   Box,
   Button,
+  Chip,
   CircularProgress,
   FormControl,
   FormControlLabel,
@@ -24,6 +25,7 @@ import type { SelectChangeEvent } from "@mui/material";
 import { Clear, ExpandMore, PlayArrow, Upload } from "@mui/icons-material";
 import type { AnalyzeRequest, ModelsResponse } from "../types";
 import { getModelDescription, getModelLabel } from "../utils/modelLabels";
+import { uploadFile } from "../api/client";
 
 // Fields that ArticleInput owns (text, metadata — no pipeline/model)
 type ArticleFields = Omit<AnalyzeRequest, "pipeline" | "model">;
@@ -47,9 +49,11 @@ function ArticleInput({
   hideSubmitButton = false,
   onRequestChange,
 }: ArticleInputProps): React.ReactElement {
-  const [inputMode, setInputMode] = useState<"text" | "file" | "url">("text");
+  const [inputMode, setInputMode] = useState<"text" | "file">("text");
   const [textValue, setTextValue] = useState<string>("");
-  const [fileName, setFileName] = useState<string | null>(null);
+  const [isUploading, setIsUploading] = useState<boolean>(false);
+  const [uploadError, setUploadError] = useState<string | null>(null);
+  const [extractedInfo, setExtractedInfo] = useState<{ filename: string; char_count: number } | null>(null);
   const [title, setTitle] = useState<string>("");
   const [publicationDate, setPublicationDate] = useState<string>("");
   const [source, setSource] = useState<string>("");
@@ -83,41 +87,37 @@ function ArticleInput({
     newMode: string | null,
   ): void => {
     if (newMode !== null) {
-      setInputMode(newMode as "text" | "file" | "url");
+      setInputMode(newMode as "text" | "file");
     }
   };
 
-  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>): void => {
+  const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>): Promise<void> => {
     const file = e.target.files?.[0];
     if (!file) return;
-    setFileName(file.name);
-    const reader = new FileReader();
-    reader.onload = (event): void => {
-      const content = event.target?.result as string;
-      if (file.name.endsWith(".json")) {
-        try {
-          const parsed = JSON.parse(content) as Record<string, unknown>;
-          if (typeof parsed.text === "string") setTextValue(parsed.text);
-          if (typeof parsed.title === "string") setTitle(parsed.title);
-          if (typeof parsed.source === "string") setSource(parsed.source);
-          if (typeof parsed.publication_date === "string")
-            setPublicationDate(parsed.publication_date);
-        } catch {
-          setTextValue(content);
-        }
-      } else {
-        setTextValue(content);
-      }
-    };
-    reader.readAsText(file);
+    setUploadError(null);
+    setExtractedInfo(null);
+    setIsUploading(true);
+    try {
+      const result = await uploadFile(file);
+      setTextValue(result.text);
+      setExtractedInfo({ filename: result.filename, char_count: result.char_count });
+      setInputMode("text");
+    } catch (err: unknown) {
+      const msg =
+        (err as { response?: { data?: { detail?: string } } })?.response?.data?.detail ??
+        "Upload failed";
+      setUploadError(msg);
+    } finally {
+      setIsUploading(false);
+      if (fileInputRef.current) fileInputRef.current.value = "";
+    }
   };
 
   const handleClearFile = (): void => {
-    setFileName(null);
+    setExtractedInfo(null);
+    setUploadError(null);
     setTextValue("");
-    if (fileInputRef.current) {
-      fileInputRef.current.value = "";
-    }
+    if (fileInputRef.current) fileInputRef.current.value = "";
   };
 
   const handleSubmit = (): void => {
@@ -143,7 +143,6 @@ function ArticleInput({
       >
         <ToggleButton value="text">Paste Text</ToggleButton>
         <ToggleButton value="file">Upload File</ToggleButton>
-        <ToggleButton value="url">URL</ToggleButton>
       </ToggleButtonGroup>
 
       {inputMode === "text" && (
@@ -157,13 +156,20 @@ function ArticleInput({
             onChange={(e) => setTextValue(e.target.value)}
             sx={{ "& .MuiInputBase-input": { fontFamily: "IBM Plex Mono, monospace" } }}
           />
-          <Typography
-            variant="caption"
-            color="text.secondary"
-            sx={{ mt: 0.5, display: "block" }}
-          >
-            {textValue.length} characters
-          </Typography>
+          <Box sx={{ mt: 0.5, display: "flex", alignItems: "center", gap: 1, flexWrap: "wrap" }}>
+            <Typography variant="caption" color="text.secondary">
+              {textValue.length} characters
+            </Typography>
+            {extractedInfo && (
+              <Chip
+                size="small"
+                label={`Extracted from: ${extractedInfo.filename} (${extractedInfo.char_count} chars)`}
+                onDelete={handleClearFile}
+                color="info"
+                variant="outlined"
+              />
+            )}
+          </Box>
         </Box>
       )}
 
@@ -171,7 +177,7 @@ function ArticleInput({
         <Box sx={{ display: "flex", flexDirection: "column", gap: 1.5 }}>
           <input
             type="file"
-            accept=".txt,.json"
+            accept=".txt,.pdf,.docx,.doc"
             ref={fileInputRef}
             onChange={handleFileChange}
             style={{ display: "none" }}
@@ -179,44 +185,34 @@ function ArticleInput({
           <Box sx={{ display: "flex", alignItems: "center", gap: 1.5 }}>
             <Button
               variant="outlined"
-              startIcon={<Upload />}
-              onClick={() => fileInputRef.current?.click()}
+              startIcon={isUploading ? <CircularProgress size={18} color="inherit" /> : <Upload />}
+              onClick={() => !isUploading && fileInputRef.current?.click()}
+              disabled={isUploading}
             >
-              Choose File
+              {isUploading ? "Extracting..." : "Choose File"}
             </Button>
-            {fileName && (
-              <>
-                <Typography variant="body2" sx={{ flex: 1 }}>
-                  {fileName}
-                </Typography>
-                <Button
-                  size="small"
-                  color="inherit"
-                  startIcon={<Clear />}
-                  onClick={handleClearFile}
-                >
-                  Clear
-                </Button>
-              </>
+            {!isUploading && extractedInfo && (
+              <Button
+                size="small"
+                color="inherit"
+                startIcon={<Clear />}
+                onClick={handleClearFile}
+              >
+                Clear
+              </Button>
             )}
           </Box>
-          {textValue && (
-            <Typography variant="caption" color="text.secondary">
-              {textValue.length} characters loaded
+          {uploadError && (
+            <Typography variant="caption" color="error">
+              {uploadError}
             </Typography>
           )}
+          <Typography variant="caption" color="text.secondary">
+            Supported formats: .txt, .pdf, .docx
+          </Typography>
         </Box>
       )}
 
-      {inputMode === "url" && (
-        <TextField
-          fullWidth
-          disabled
-          placeholder="https://..."
-          helperText="Coming soon — requires RSS/API integration"
-        />
-      )}
-
       <Accordion
         disableGutters
         elevation={0}

frontend/src/components/BatchTab.tsx

@@ -0,0 +1,506 @@
+import React, { useRef, useState } from "react";
+import {
+  Alert,
+  Box,
+  Button,
+  Checkbox,
+  Chip,
+  CircularProgress,
+  Collapse,
+  FormControl,
+  FormControlLabel,
+  IconButton,
+  InputLabel,
+  LinearProgress,
+  MenuItem,
+  Paper,
+  Select,
+  Stack,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableRow,
+  TableSortLabel,
+  TextField,
+  Typography,
+} from "@mui/material";
+import type { SelectChangeEvent } from "@mui/material";
+import { Add, Delete, PlayArrow } from "@mui/icons-material";
+import axios from "axios";
+import type { BatchArticleResult, BatchResponse, ModelsResponse } from "../types";
+import { analyzeBatch } from "../api/client";
+import { getModelLabel } from "../utils/modelLabels";
+
+interface BatchTabProps {
+  availableModels?: ModelsResponse;
+}
+
+interface BatchRow {
+  id: number;
+  text: string;
+  title: string;
+}
+
+type SortField = "score" | "n_claims" | "n_inconsistencies" | "n_cross_article_inconsistencies" | "processing_time_ms";
+
+function scoreColor(score: number): "success" | "warning" | "default" | "error" {
+  if (score >= 0.8) return "success";
+  if (score >= 0.5) return "warning";
+  if (score >= 0.2) return "default";
+  return "error";
+}
+
+const MAX_ROWS = 20;
+let _rowIdCounter = 0;
+function nextId(): number {
+  return ++_rowIdCounter;
+}
+
+function BatchTab({ availableModels }: BatchTabProps): React.ReactElement {
+  const [rows, setRows] = useState<BatchRow[]>([
+    { id: nextId(), text: "", title: "" },
+    { id: nextId(), text: "", title: "" },
+  ]);
+  const [pipeline, setPipeline] = useState<"spacy" | "llm">("spacy");
+  const [model, setModel] = useState<string>("");
+  const [persist, setPersist] = useState<boolean>(true);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [result, setResult] = useState<BatchResponse | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [sortField, setSortField] = useState<SortField>("score");
+  const [sortDir, setSortDir] = useState<"asc" | "desc">("asc");
+  const [expandedId, setExpandedId] = useState<string | null>(null);
+
+  const pipelineMeta = availableModels
+    ? pipeline === "llm"
+      ? availableModels.llm
+      : availableModels.spacy
+    : null;
+
+  const addRow = (): void => {
+    if (rows.length >= MAX_ROWS) return;
+    setRows((prev) => [...prev, { id: nextId(), text: "", title: "" }]);
+  };
+
+  const removeRow = (id: number): void => {
+    if (rows.length <= 1) return;
+    setRows((prev) => prev.filter((r) => r.id !== id));
+  };
+
+  const updateRow = (id: number, field: "text" | "title", value: string): void => {
+    setRows((prev) =>
+      prev.map((r) => (r.id === id ? { ...r, [field]: value } : r))
+    );
+  };
+
+  const handlePipelineChange = (e: SelectChangeEvent<string>): void => {
+    const p = e.target.value as "spacy" | "llm";
+    setPipeline(p);
+    if (availableModels) {
+      setModel(p === "llm" ? availableModels.llm.default : availableModels.spacy.default);
+    }
+  };
+
+  const handleSort = (field: SortField): void => {
+    if (sortField === field) {
+      setSortDir((d) => (d === "asc" ? "desc" : "asc"));
+    } else {
+      setSortField(field);
+      setSortDir("asc");
+    }
+  };
+
+  const validRows = rows.filter((r) => r.text.trim().length >= 20);
+
+  const handleSubmit = async (): Promise<void> => {
+    if (validRows.length === 0) return;
+    setIsLoading(true);
+    setError(null);
+    setResult(null);
+    setExpandedId(null);
+
+    try {
+      const response = await analyzeBatch({
+        articles: validRows.map((r) => ({
+          text: r.text.trim(),
+          title: r.title.trim() || undefined,
+        })),
+        pipeline,
+        model: model || undefined,
+        persist,
+      });
+      setResult(response);
+    } catch (err: unknown) {
+      if (axios.isAxiosError(err)) {
+        const detail = err.response?.data?.detail as string | undefined;
+        setError(detail ?? err.message);
+      } else if (err instanceof Error) {
+        setError(err.message);
+      } else {
+        setError("An unexpected error occurred");
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const sortedResults: BatchArticleResult[] = result
+    ? [...result.results].sort((a, b) => {
+        const aVal = a[sortField] as number;
+        const bVal = b[sortField] as number;
+        return sortDir === "asc" ? aVal - bVal : bVal - aVal;
+      })
+    : [];
+
+  return (
+    <Stack spacing={3}>
+      {/* Input section */}
+      <Paper variant="outlined" sx={{ p: 2.5 }}>
+        <Typography variant="subtitle2" sx={{ mb: 2 }}>
+          Articles
+        </Typography>
+
+        <Stack spacing={2}>
+          {rows.map((row, idx) => (
+            <Box key={row.id} sx={{ display: "flex", gap: 1.5, alignItems: "flex-start" }}>
+              <Typography
+                variant="caption"
+                color="text.secondary"
+                sx={{ pt: 1.5, minWidth: 20, textAlign: "right" }}
+              >
+                {idx + 1}
+              </Typography>
+              <Box sx={{ flex: 1, display: "flex", flexDirection: "column", gap: 1 }}>
+                <TextField
+                  size="small"
+                  placeholder="Article title (optional)"
+                  value={row.title}
+                  onChange={(e) => updateRow(row.id, "title", e.target.value)}
+                  fullWidth
+                />
+                <TextField
+                  multiline
+                  minRows={4}
+                  fullWidth
+                  placeholder="Paste article text here... (min 20 characters)"
+                  value={row.text}
+                  onChange={(e) => updateRow(row.id, "text", e.target.value)}
+                  error={row.text.length > 0 && row.text.trim().length < 20}
+                  helperText={row.text.length > 0 ? `${row.text.length} characters` : undefined}
+                  sx={{ "& .MuiInputBase-input": { fontFamily: "IBM Plex Mono, monospace", fontSize: 13 } }}
+                />
+              </Box>
+              <IconButton
+                size="small"
+                onClick={() => removeRow(row.id)}
+                disabled={rows.length <= 1}
+                sx={{ mt: 0.5 }}
+              >
+                <Delete fontSize="small" />
+              </IconButton>
+            </Box>
+          ))}
+
+          <Box>
+            <Button
+              size="small"
+              startIcon={<Add />}
+              onClick={addRow}
+              disabled={rows.length >= MAX_ROWS}
+            >
+              Add Article {rows.length >= MAX_ROWS ? `(max ${MAX_ROWS})` : ""}
+            </Button>
+          </Box>
+        </Stack>
+
+        <Box
+          sx={{
+            mt: 2.5,
+            pt: 2,
+            borderTop: "1px solid",
+            borderColor: "divider",
+            display: "flex",
+            gap: 2,
+            flexWrap: "wrap",
+            alignItems: "center",
+          }}
+        >
+          <FormControl size="small" sx={{ minWidth: 130 }}>
+            <InputLabel>Pipeline</InputLabel>
+            <Select value={pipeline} label="Pipeline" onChange={handlePipelineChange}>
+              <MenuItem value="spacy">spaCy</MenuItem>
+              <MenuItem value="llm">LLM</MenuItem>
+            </Select>
+          </FormControl>
+
+          {pipelineMeta && (
+            <FormControl size="small" sx={{ minWidth: 180 }}>
+              <InputLabel>Model</InputLabel>
+              <Select
+                value={model || pipelineMeta.default}
+                label="Model"
+                onChange={(e: SelectChangeEvent<string>) => setModel(e.target.value)}
+              >
+                {pipelineMeta.models.map((m) => (
+                  <MenuItem key={m} value={m}>
+                    {getModelLabel(m)}
+                  </MenuItem>
+                ))}
+              </Select>
+            </FormControl>
+          )}
+
+          <FormControlLabel
+            control={
+              <Checkbox
+                size="small"
+                checked={persist}
+                onChange={(e) => setPersist(e.target.checked)}
+              />
+            }
+            label={
+              <Typography variant="body2">Save to Neo4j for cross-article analysis</Typography>
+            }
+          />
+
+          <Box sx={{ ml: "auto" }}>
+            <Button
+              variant="contained"
+              startIcon={
+                isLoading ? (
+                  <CircularProgress size={18} color="inherit" />
+                ) : (
+                  <PlayArrow />
+                )
+              }
+              disabled={validRows.length === 0 || isLoading}
+              onClick={handleSubmit}
+            >
+              {isLoading ? `Analyzing ${validRows.length} articles…` : "Analyze Batch"}
+            </Button>
+          </Box>
+        </Box>
+      </Paper>
+
+      {/* Loading indicator */}
+      {isLoading && (
+        <Box>
+          <LinearProgress />
+          <Typography variant="caption" color="text.secondary" sx={{ mt: 0.5, display: "block" }} component="p">
+            Analyzing {validRows.length} article{validRows.length !== 1 ? "s" : ""}…
+          </Typography>
+        </Box>
+      )}
+
+      {error && (
+        <Alert severity="error" onClose={() => setError(null)}>
+          {error}
+        </Alert>
+      )}
+
+      {/* Results section */}
+      {result && (
+        <Paper variant="outlined" sx={{ p: 2.5 }}>
+          {/* Aggregate stats */}
+          <Box sx={{ display: "flex", gap: 3, flexWrap: "wrap", mb: 2.5 }}>
+            <StatBox label="Articles" value={result.total_articles} />
+            <StatBox
+              label="Mean TCS"
+              value={result.avg_score.toFixed(3)}
+              color={
+                result.avg_score >= 0.8
+                  ? "success.main"
+                  : result.avg_score >= 0.5
+                    ? "warning.main"
+                    : "error.main"
+              }
+            />
+            <StatBox
+              label="Total claims"
+              value={result.results.reduce((s, r) => s + r.n_claims, 0)}
+            />
+            <StatBox
+              label="Inconsistencies"
+              value={result.results.reduce((s, r) => s + r.n_inconsistencies, 0)}
+            />
+            <StatBox label="Cross-article conflicts" value={result.total_cross_article_conflicts} />
+            {result.persisted && (
+              <Chip label="Saved to Neo4j" size="small" color="success" variant="outlined" />
+            )}
+          </Box>
+
+          {/* Results table */}
+          <Table size="small">
+            <TableHead>
+              <TableRow>
+                <TableCell sx={{ width: 36 }}>#</TableCell>
+                <TableCell>Title</TableCell>
+                <SortHeaderCell field="score" active={sortField} dir={sortDir} onSort={handleSort}>
+                  TCS Score
+                </SortHeaderCell>
+                <SortHeaderCell field="n_claims" active={sortField} dir={sortDir} onSort={handleSort}>
+                  Claims
+                </SortHeaderCell>
+                <SortHeaderCell field="n_inconsistencies" active={sortField} dir={sortDir} onSort={handleSort}>
+                  Inconsistencies
+                </SortHeaderCell>
+                <SortHeaderCell
+                  field="n_cross_article_inconsistencies"
+                  active={sortField}
+                  dir={sortDir}
+                  onSort={handleSort}
+                >
+                  Cross-Article
+                </SortHeaderCell>
+                <SortHeaderCell
+                  field="processing_time_ms"
+                  active={sortField}
+                  dir={sortDir}
+                  onSort={handleSort}
+                >
+                  Time
+                </SortHeaderCell>
+              </TableRow>
+            </TableHead>
+            <TableBody>
+              {sortedResults.map((row, idx) => (
+                <React.Fragment key={row.article_id}>
+                  <TableRow
+                    hover
+                    sx={{ cursor: "pointer" }}
+                    onClick={() =>
+                      setExpandedId((prev) =>
+                        prev === row.article_id ? null : row.article_id
+                      )
+                    }
+                  >
+                    <TableCell sx={{ color: "text.secondary" }}>{idx + 1}</TableCell>
+                    <TableCell sx={{ maxWidth: 220 }}>
+                      <Typography variant="body2" noWrap title={row.title || row.article_id}>
+                        {row.title || <em style={{ opacity: 0.6 }}>Untitled</em>}
+                      </Typography>
+                      {row.error && (
+                        <Typography variant="caption" color="error">
+                          Error
+                        </Typography>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <Chip
+                        label={row.score.toFixed(3)}
+                        size="small"
+                        color={scoreColor(row.score)}
+                      />
+                    </TableCell>
+                    <TableCell>{row.n_claims}</TableCell>
+                    <TableCell>{row.n_inconsistencies}</TableCell>
+                    <TableCell>
+                      {row.n_cross_article_inconsistencies > 0 ? (
+                        <Chip
+                          label={row.n_cross_article_inconsistencies}
+                          size="small"
+                          color="warning"
+                        />
+                      ) : (
+                        <Typography variant="body2" color="text.secondary">
+                          0
+                        </Typography>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <Typography variant="body2" color="text.secondary">
+                        {Math.round(row.processing_time_ms)}ms
+                      </Typography>
+                    </TableCell>
+                  </TableRow>
+
+                  {/* Expandable detail row */}
+                  <TableRow>
+                    <TableCell colSpan={7} sx={{ p: 0, border: 0 }}>
+                      <Collapse in={expandedId === row.article_id} unmountOnExit>
+                        <Box sx={{ px: 3, py: 1.5, bgcolor: "action.hover" }}>
+                          <Typography variant="body2" sx={{ mb: 1 }}>
+                            {row.summary}
+                          </Typography>
+                          {row.cross_article_conflicts.length > 0 && (
+                            <Stack spacing={0.5}>
+                              <Typography variant="caption" color="text.secondary">
+                                Cross-article conflicts:
+                              </Typography>
+                              {row.cross_article_conflicts.map((c, i) => (
+                                <Typography key={i} variant="caption" color="warning.main">
+                                  • {c.description}
+                                </Typography>
+                              ))}
+                            </Stack>
+                          )}
+                          {row.error && (
+                            <Typography variant="caption" color="error">
+                              {row.error}
+                            </Typography>
+                          )}
+                        </Box>
+                      </Collapse>
+                    </TableCell>
+                  </TableRow>
+                </React.Fragment>
+              ))}
+            </TableBody>
+          </Table>
+        </Paper>
+      )}
+    </Stack>
+  );
+}
+
+// Stat summary box used in aggregate row
+function StatBox({
+  label,
+  value,
+  color,
+}: {
+  label: string;
+  value: string | number;
+  color?: string;
+}): React.ReactElement {
+  return (
+    <Box>
+      <Typography variant="caption" color="text.secondary" sx={{ display: "block" }}>
+        {label}
+      </Typography>
+      <Typography variant="h6" sx={{ color: color ?? "text.primary", lineHeight: 1.2 }}>
+        {value}
+      </Typography>
+    </Box>
+  );
+}
+
+// Sortable table header cell
+function SortHeaderCell({
+  field,
+  active,
+  dir,
+  onSort,
+  children,
+}: {
+  field: SortField;
+  active: SortField;
+  dir: "asc" | "desc";
+  onSort: (f: SortField) => void;
+  children: React.ReactNode;
+}): React.ReactElement {
+  return (
+    <TableCell>
+      <TableSortLabel
+        active={active === field}
+        direction={active === field ? dir : "asc"}
+        onClick={() => onSort(field)}
+      >
+        {children}
+      </TableSortLabel>
+    </TableCell>
+  );
+}
+
+export default BatchTab;

frontend/src/types/api.ts

@@ -14,6 +14,7 @@ export interface AnalyzeRequest {
   source?: string;
   pipeline?: "spacy" | "llm";
   model?: string;
+  persist?: boolean;
 }
 
 export interface InconsistencyResponse {
@@ -65,6 +66,60 @@ export interface AnalyzeResponse {
   pipeline: string;
   model: string;
   processing_time_ms: number;
+  article_id?: string | null;
+  cross_article_inconsistencies?: InconsistencyResponse[];
+}
+
+// batch schemas
+export interface BatchArticle {
+  text: string;
+  title?: string;
+  publication_date?: string;
+  source?: string;
+}
+
+export interface BatchRequest {
+  articles: BatchArticle[];
+  pipeline: string;
+  model?: string;
+  persist: boolean;
+}
+
+export interface BatchArticleResult {
+  article_id: string;
+  title: string;
+  score: number;
+  label: string;
+  summary: string;
+  n_claims: number;
+  n_inconsistencies: number;
+  n_cross_article_inconsistencies: number;
+  cross_article_conflicts: InconsistencyResponse[];
+  processing_time_ms: number;
+  error?: string | null;
+}
+
+export interface BatchResponse {
+  results: BatchArticleResult[];
+  total_articles: number;
+  total_cross_article_conflicts: number;
+  avg_score: number;
+  neo4j_enabled: boolean;
+  persisted: boolean;
+}
+
+// article history schemas
+export interface StoredArticle {
+  article_id: string;
+  title: string | null;
+  source: string | null;
+  analyzed_at: string | null;
+  fact_count: number;
+}
+
+export interface ArticlesResponse {
+  articles: StoredArticle[];
+  neo4j_enabled: boolean;
 }
 
 // compare schemas

requirements.txt

@@ -1,17 +1,20 @@
-# Core Pipeline
-spacy>=3.7
+# Core pipeline
+spacy
 dateparser
-networkx>=3.0
-networkx-temporal
-SPARQLWrapper
+networkx
+neo4j
 
 # API
 fastapi
 uvicorn[standard]
-pydantic>=2.0
+pydantic
+python-multipart
 
-# Data Ingestion
-feedparser
+# File upload extraction
+python-docx
+PyPDF2
+
+# HTTP and env
 requests
 python-dotenv
 
@@ -19,6 +22,3 @@ python-dotenv
 pytest
 pytest-asyncio
 httpx
-
-# Notebooks
-jupyter

training/Modelfile

@@ -1,32 +0,0 @@
-FROM ./output/fakenews-ner.gguf
-
-PARAMETER temperature 0.1
-PARAMETER num_predict 4096
-
-SYSTEM """You are a temporal fact extraction system. Given a news article, extract ALL temporal facts.
-
-For each fact, return a JSON object with:
-- "subject": the main entity (person, organization, location)
-- "subject_type": one of PERSON, ORG, GPE, EVENT, NORP, PRODUCT, OTHER
-- "predicate": the relationship (e.g. "holds_position", "member_of", "occurred_on", "caused", "preceded", "followed", "generic")
-- "object": the related entity or context
-- "object_type": same types as subject_type
-- "time_expression": the temporal expression exactly as it appears in the text
-- "time_start": start date if it's a range (ISO format YYYY-MM-DD or null)
-- "time_end": end date if it's a range (ISO format YYYY-MM-DD or null)
-- "time_point": specific date if it's a single point (ISO format or null)
-- "source_sentence": the original sentence from the article that contains this fact
-- "confidence": your confidence 0.0–1.0
-
-Examples:
-
-Input: "Barack Obama served as the 44th President of the United States from January 2009 to January 2017."
-Output:
-[{"subject": "Barack Obama", "subject_type": "PERSON", "predicate": "holds_position", "object": "44th President of the United States", "object_type": "ORG", "time_expression": "from January 2009 to January 2017", "time_start": "2009-01-20", "time_end": "2017-01-20", "time_point": null, "source_sentence": "Barack Obama served as the 44th President of the United States from January 2009 to January 2017.", "confidence": 0.95}]
-
-Input: "The Affordable Care Act was signed into law on March 23, 2010 by President Obama."
-Output:
-[{"subject": "Affordable Care Act", "subject_type": "EVENT", "predicate": "occurred_on", "object": "signed into law", "object_type": "EVENT", "time_expression": "March 23, 2010", "time_start": null, "time_end": null, "time_point": "2010-03-23", "source_sentence": "The Affordable Care Act was signed into law on March 23, 2010 by President Obama.", "confidence": 0.92},
-{"subject": "President Obama", "subject_type": "PERSON", "predicate": "generic", "object": "Affordable Care Act", "object_type": "EVENT", "time_expression": "March 23, 2010", "time_start": null, "time_end": null, "time_point": "2010-03-23", "source_sentence": "The Affordable Care Act was signed into law on March 23, 2010 by President Obama.", "confidence": 0.88}]
-
-Return ONLY a JSON array. No explanations, no markdown fences."""

training/README.md

@@ -1,120 +0,0 @@
-# Fine-Tuning: fakenews-ner
-
-QLoRA fine-tuning pipeline for the `fakenews-ner` model — a Mistral-7B variant
-specialized for temporal fact extraction from political news articles.
-
-The fine-tuned model is exported to GGUF and loaded into Ollama as `fakenews-ner`,
-where it replaces zero-shot inference with task-specific extraction.
-
-## Prerequisites
-
-**Hardware:** CUDA-capable GPU with at least 8 GB VRAM (developed on RTX 4060 Laptop).
-
-**Software:**
-- Python 3.11
-- CUDA 12.1+ with matching PyTorch
-- Ollama (for the final registration step)
-
-**Install training dependencies** (separate from the main backend requirements):
-
-```bash
-pip install -r training/requirements.txt
-```
-
-unsloth must be installed with the correct CUDA index. If the above fails, follow
-the manual install at https://docs.unsloth.ai/get-started/installation.
-
-## Steps
-
-### 1 — Prepare dataset (~5 minutes)
-
-Runs `SpacyExtractor(en_core_web_trf)` on each article to produce silver-label
-temporal facts, then formats them as instruction/input/output triplets.
-
-```bash
-# Default: reads data/datasets/liar/, writes training/data/
-python training/prepare_dataset.py
-
-# Custom article directory (.txt files)
-python training/prepare_dataset.py --input-dir path/to/articles/ --max-articles 300
-```
-
-**Input format:** either LIAR-style `.tsv` files (id, label, statement, ...) or
-plain `.txt` files, one article per file.
-
-**Output:** `training/data/train.jsonl` (80%) and `training/data/eval.jsonl` (20%).
-
-Articles where spaCy extracts zero temporal facts are skipped — they provide no
-training signal. Expect 100–150 usable examples from 200 articles.
-
-### 2 — Train (~1–2 hours on RTX 4060)
-
-```bash
-python training/train_qlora.py
-```
-
-LoRA configuration: r=16, alpha=32, target modules q/k/v/o projections.
-Batch size 1 with 4 gradient accumulation steps (effective batch = 4).
-Adapter weights are saved to `training/output/fakenews-ner-lora/`.
-
-Optional overrides:
-
-```bash
-python training/train_qlora.py --epochs 5 --lr 1e-4
-python training/train_qlora.py --base-model unsloth/llama-3-8b-Instruct-bnb-4bit
-```
-
-### 3 — Export to GGUF (~10 minutes)
-
-Merges the LoRA adapter into the base model and quantizes to Q4_K_M.
-
-```bash
-python training/export_gguf.py
-```
-
-Output: `training/output/fakenews-ner.gguf`
-
-### 4 — Register in Ollama
-
-```bash
-# Linux / macOS / Git Bash
-bash training/register_ollama.sh
-
-# Windows PowerShell
-.\training\register_ollama.ps1
-```
-
-This runs `ollama create fakenews-ner -f training/Modelfile`. The Modelfile points
-to the `.gguf` file and embeds the system prompt with few-shot examples.
-
-Verify the model is available:
-
-```bash
-ollama list
-ollama run fakenews-ner "Extract temporal facts from: Obama was president from 2009 to 2017."
-```
-
-Once registered, set `LLM_MODELS=sciphi/triplex,fakenews-ner` and
-`LLM_DEFAULT_MODEL=fakenews-ner` in `.env` to use it as the default LLM pipeline.
-
-## File Overview
-
-| File | Purpose |
-|------|---------|
-| `prepare_dataset.py` | Generate train/eval JSONL from articles using spaCy silver labels |
-| `train_qlora.py` | QLoRA fine-tuning with unsloth + SFTTrainer |
-| `export_gguf.py` | Merge adapter and export to GGUF Q4_K_M |
-| `Modelfile` | Ollama model definition (FROM + SYSTEM prompt) |
-| `register_ollama.sh` | Register GGUF in Ollama (Linux/macOS/Git Bash) |
-| `register_ollama.ps1` | Register GGUF in Ollama (Windows PowerShell) |
-| `data/` | Generated train.jsonl and eval.jsonl (git-ignored) |
-| `output/` | LoRA adapter and GGUF file (git-ignored) |
-
-## Expected VRAM Usage
-
-| Stage | VRAM |
-|-------|------|
-| Prepare dataset (spaCy en_core_web_trf) | ~2 GB |
-| Training (Mistral-7B 4-bit + LoRA) | ~7–7.5 GB |
-| GGUF export (merge + quantize) | ~7 GB |
-| Ollama inference (Q4_K_M) | ~5 GB |

training/export_gguf.py

@@ -1,96 +0,0 @@
-"""
-Merge LoRA adapter with the base model and export to GGUF Q4_K_M format.
-
-The resulting .gguf file can be registered directly in Ollama via register_ollama.sh
-or register_ollama.ps1.
-
-Usage:
-    python training/export_gguf.py
-    python training/export_gguf.py --adapter-dir training/output/fakenews-ner-lora
-    python training/export_gguf.py --output training/output/fakenews-ner.gguf
-"""
-
-from __future__ import annotations
-
-import argparse
-import logging
-from pathlib import Path
-
-logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-DEFAULT_ADAPTER_DIR = Path(__file__).parent / "output" / "fakenews-ner-lora"
-DEFAULT_OUTPUT = Path(__file__).parent / "output" / "fakenews-ner.gguf"
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Merge LoRA adapter and export to GGUF for Ollama"
-    )
-    parser.add_argument(
-        "--adapter-dir",
-        type=Path,
-        default=DEFAULT_ADAPTER_DIR,
-        help="Directory containing the saved LoRA adapter (output of train_qlora.py)",
-    )
-    parser.add_argument(
-        "--output",
-        type=Path,
-        default=DEFAULT_OUTPUT,
-        help="Path for the exported .gguf file",
-    )
-    parser.add_argument(
-        "--quantization",
-        default="q4_k_m",
-        choices=["q4_k_m", "q8_0", "f16"],
-        help="GGUF quantization type (q4_k_m recommended for 8 GB VRAM inference)",
-    )
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-
-    if not args.adapter_dir.exists():
-        raise FileNotFoundError(
-            f"Adapter directory not found: {args.adapter_dir}\n"
-            "Run train_qlora.py first."
-        )
-
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-
-    logger.info(f"Loading adapter from : {args.adapter_dir}")
-    logger.info(f"Output GGUF path     : {args.output}")
-    logger.info(f"Quantization         : {args.quantization}")
-
-    from unsloth import FastLanguageModel
-
-    # Reload the adapter (unsloth re-attaches it to the base model automatically)
-    model, tokenizer = FastLanguageModel.from_pretrained(
-        model_name=str(args.adapter_dir),
-        max_seq_length=2048,
-        dtype=None,
-        load_in_4bit=True,
-    )
-
-    logger.info("Merging adapter weights into base model...")
-
-    # save_pretrained_gguf merges, quantizes, and writes the .gguf in one step
-    model.save_pretrained_gguf(
-        str(args.output.with_suffix("")),
-        tokenizer,
-        quantization_method=args.quantization,
-    )
-
-    # unsloth appends the quantization suffix; rename to the clean target path
-    candidate = args.output.parent / f"{args.output.stem}-{args.quantization}.gguf"
-    if candidate.exists() and candidate != args.output:
-        candidate.rename(args.output)
-        logger.info(f"Renamed {candidate.name} -> {args.output.name}")
-
-    logger.info(f"Export complete: {args.output}")
-    logger.info("Next step: run register_ollama.sh (or .ps1) to load into Ollama")
-
-
-if __name__ == "__main__":
-    main()

training/prepare_dataset.py

@@ -1,229 +0,0 @@
-"""
-Prepare instruction-tuning dataset for fakenews-ner fine-tuning.
-
-Uses SpacyExtractor (en_core_web_trf) as a silver-label teacher to annotate
-articles, then formats each article as an instruction/input/output triplet
-matching the LLMExtractor prompt schema.
-
-Usage:
-    python training/prepare_dataset.py
-    python training/prepare_dataset.py --input-dir data/datasets/liar --max-articles 500
-    python training/prepare_dataset.py --input-dir my_articles/ --split-ratio 0.85
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import logging
-import sys
-from pathlib import Path
-from typing import Optional
-
-logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-# Repo root must be on sys.path so backend imports resolve
-_REPO_ROOT = Path(__file__).parent.parent
-if str(_REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT))
-
-from backend.pipeline.extraction.llm_extractor import SYSTEM_PROMPT, USER_PROMPT_TEMPLATE
-from backend.pipeline.extraction.spacy_extractor import SpacyExtractor
-from backend.pipeline.graph.models import Article, TemporalFact
-
-
-def fact_to_dict(fact: TemporalFact) -> dict:
-    """Convert a TemporalFact to the JSON schema expected by the LLM."""
-    time_expr = ""
-    if fact.time_point:
-        time_expr = fact.time_point.raw_text
-    elif fact.time_start:
-        time_expr = fact.time_start.raw_text
-
-    return {
-        "subject": fact.subject.text,
-        "subject_type": fact.subject.entity_type.value,
-        "predicate": fact.predicate.value,
-        "object": fact.object.text,
-        "object_type": fact.object.entity_type.value,
-        "time_expression": time_expr,
-        "time_start": fact.time_start.date_string if fact.time_start else None,
-        "time_end": fact.time_end.date_string if fact.time_end else None,
-        "time_point": fact.time_point.date_string if fact.time_point else None,
-        "source_sentence": fact.source_sentence,
-        "confidence": round(fact.extraction_confidence, 2),
-    }
-
-
-def load_articles_tsv(tsv_path: Path, max_articles: int) -> list[Article]:
-    """Load articles from a LIAR-style TSV file (no header row).
-
-    Column layout: id, label, statement, subject, speaker, job, state,
-    party, counts x5, context
-    """
-    articles = []
-    with open(tsv_path, encoding="utf-8") as f:
-        for line in f:
-            if len(articles) >= max_articles:
-                break
-            parts = line.rstrip("\n").split("\t")
-            if len(parts) < 3:
-                continue
-            text = parts[2].strip()
-            if not text:
-                continue
-            speaker = parts[4].strip() if len(parts) > 4 else ""
-            articles.append(Article(text=text, title=speaker))
-    return articles
-
-
-def load_articles_txt(txt_dir: Path, max_articles: int) -> list[Article]:
-    """Load articles from a directory of plain-text .txt files."""
-    articles = []
-    for p in sorted(txt_dir.glob("*.txt")):
-        if len(articles) >= max_articles:
-            break
-        text = p.read_text(encoding="utf-8").strip()
-        if text:
-            articles.append(Article(text=text, title=p.stem))
-    return articles
-
-
-def load_articles(input_dir: Path, max_articles: int) -> list[Article]:
-    """Auto-detect TSV files or .txt files in the input directory."""
-    tsv_files = sorted(input_dir.glob("*.tsv")) + sorted(input_dir.glob("*.csv"))
-    if tsv_files:
-        logger.info(f"Found TSV file(s): {[f.name for f in tsv_files]}")
-        articles: list[Article] = []
-        for tsv in tsv_files:
-            articles.extend(load_articles_tsv(tsv, max_articles - len(articles)))
-            if len(articles) >= max_articles:
-                break
-        return articles
-
-    txt_files = list(input_dir.glob("*.txt"))
-    if txt_files:
-        logger.info(f"Found {len(txt_files)} .txt file(s)")
-        return load_articles_txt(input_dir, max_articles)
-
-    logger.warning(f"No .tsv or .txt files found in {input_dir}")
-    return []
-
-
-def build_example(article: Article, facts: list[TemporalFact]) -> dict:
-    """Format a single article + its silver facts as an instruction example."""
-    pub_date_str = (
-        article.publication_date.strftime("%Y-%m-%d")
-        if article.publication_date else "unknown"
-    )
-    user_input = USER_PROMPT_TEMPLATE.format(
-        title=article.title or "(untitled)",
-        pub_date=pub_date_str,
-        text=article.text[:4000],
-    )
-    output_json = json.dumps([fact_to_dict(f) for f in facts], ensure_ascii=False)
-    return {
-        "instruction": SYSTEM_PROMPT,
-        "input": user_input,
-        "output": output_json,
-    }
-
-
-def write_jsonl(examples: list[dict], path: Path) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        for ex in examples:
-            f.write(json.dumps(ex, ensure_ascii=False) + "\n")
-    logger.info(f"Wrote {len(examples)} examples to {path}")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Prepare instruction-tuning data for fakenews-ner"
-    )
-    parser.add_argument(
-        "--input-dir",
-        type=Path,
-        default=_REPO_ROOT / "data" / "datasets" / "liar",
-        help="Directory containing .tsv or .txt article files",
-    )
-    parser.add_argument(
-        "--output-dir",
-        type=Path,
-        default=Path(__file__).parent / "data",
-        help="Directory to write train.jsonl and eval.jsonl",
-    )
-    parser.add_argument(
-        "--max-articles",
-        type=int,
-        default=200,
-        help="Maximum number of articles to process",
-    )
-    parser.add_argument(
-        "--split-ratio",
-        type=float,
-        default=0.8,
-        help="Fraction of examples to use for training (rest goes to eval)",
-    )
-    args = parser.parse_args()
-
-    if not args.input_dir.exists():
-        logger.error(f"Input directory not found: {args.input_dir}")
-        logger.error("Place LIAR .tsv files in data/datasets/liar/ or pass --input-dir")
-        sys.exit(1)
-
-    logger.info(f"Loading articles from {args.input_dir}")
-    articles = load_articles(args.input_dir, args.max_articles)
-    if not articles:
-        logger.error("No articles loaded. Exiting.")
-        sys.exit(1)
-    logger.info(f"Loaded {len(articles)} articles")
-
-    logger.info("Initialising SpacyExtractor (en_core_web_trf) — loading model once...")
-    extractor = SpacyExtractor(model_name="en_core_web_trf")
-
-    # Fail fast if model can't load
-    try:
-        _ = extractor.nlp
-    except Exception as e:
-        print(f"FATAL: Cannot load spaCy model: {e}")
-        print("Run: python -m spacy download en_core_web_trf")
-        sys.exit(1)
-
-    examples: list[dict] = []
-    skipped = 0
-
-    for i, article in enumerate(articles, start=1):
-        try:
-            facts = extractor.extract(article)
-        except Exception as e:
-            logger.warning(f"Article {i}: extraction error — {e}")
-            skipped += 1
-            continue
-
-        if not facts:
-            skipped += 1
-            continue
-
-        examples.append(build_example(article, facts))
-
-        if i % 20 == 0:
-            logger.info(f"Progress: {i}/{len(articles)} — {len(examples)} usable so far")
-
-    logger.info(
-        f"Finished: {len(examples)} usable examples, {skipped} skipped (no temporal facts)"
-    )
-
-    split = int(len(examples) * args.split_ratio)
-    train_examples = examples[:split]
-    eval_examples = examples[split:]
-
-    write_jsonl(train_examples, args.output_dir / "train.jsonl")
-    write_jsonl(eval_examples, args.output_dir / "eval.jsonl")
-
-    logger.info(f"Dataset ready: {len(train_examples)} train / {len(eval_examples)} eval")
-
-
-if __name__ == "__main__":
-    main()

training/register_ollama.ps1

@@ -1,22 +0,0 @@
-# Register the fine-tuned fakenews-ner model in Ollama using the local Modelfile.
-# Run from the repo root or the training/ directory.
-
-Set-Location $PSScriptRoot
-
-if (-not (Get-Command ollama -ErrorAction SilentlyContinue)) {
-    Write-Error "ERROR: 'ollama' not found. Install Ollama from https://ollama.com and try again."
-    exit 1
-}
-
-if (-not (Test-Path "output\fakenews-ner.gguf")) {
-    Write-Error "ERROR: output\fakenews-ner.gguf not found."
-    Write-Host "Run export_gguf.py first to generate the GGUF file."
-    exit 1
-}
-
-Write-Host "Registering model 'fakenews-ner' in Ollama..."
-ollama create fakenews-ner -f Modelfile
-
-Write-Host ""
-Write-Host "Done. Test the model with:"
-Write-Host "  ollama run fakenews-ner 'Extract temporal facts from: Obama was president from 2009 to 2017.'"

training/register_ollama.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-# Register the fine-tuned fakenews-ner model in Ollama using the local Modelfile.
-# Run from the repo root or the training/ directory — the script locates itself.
-
-cd "$(dirname "$0")"
-
-if ! command -v ollama &>/dev/null; then
-    echo "ERROR: 'ollama' not found. Install Ollama from https://ollama.com and try again."
-    exit 1
-fi
-
-if [ ! -f "output/fakenews-ner.gguf" ]; then
-    echo "ERROR: output/fakenews-ner.gguf not found."
-    echo "Run export_gguf.py first to generate the GGUF file."
-    exit 1
-fi
-
-echo "Registering model 'fakenews-ner' in Ollama..."
-ollama create fakenews-ner -f Modelfile
-
-echo ""
-echo "Done. Test the model with:"
-echo "  ollama run fakenews-ner 'Extract temporal facts from: Obama was president from 2009 to 2017.'"

training/requirements.txt

@@ -1,8 +0,0 @@
-unsloth[colab-new]
-torch>=2.1.0
-peft
-bitsandbytes
-transformers
-trl
-datasets
-accelerate

training/train_qlora.py

@@ -1,165 +0,0 @@
-"""
-QLoRA fine-tuning of Mistral-7B for temporal fact extraction (fakenews-ner).
-
-Requires unsloth and a CUDA-capable GPU. Designed for RTX 4060 Laptop (8 GB VRAM)
-using 4-bit quantization. Adapter weights are saved to --output-dir and can be
-merged + exported with export_gguf.py.
-
-Usage:
-    python training/train_qlora.py
-    python training/train_qlora.py --epochs 5 --lr 1e-4
-    python training/train_qlora.py --base-model unsloth/llama-3-8b-Instruct-bnb-4bit
-"""
-
-from __future__ import annotations
-
-import argparse
-import logging
-from pathlib import Path
-
-logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-DEFAULT_BASE_MODEL = "unsloth/mistral-7b-instruct-v0.3-bnb-4bit"
-DEFAULT_DATA_DIR = Path(__file__).parent / "data"
-DEFAULT_OUTPUT_DIR = Path(__file__).parent / "output" / "fakenews-ner-lora"
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="QLoRA fine-tuning for fakenews-ner on RTX 4060 (8 GB VRAM)"
-    )
-    parser.add_argument(
-        "--base-model",
-        default=DEFAULT_BASE_MODEL,
-        help="Hugging Face model ID or local path (must be 4-bit bnb quantized for 8 GB VRAM)",
-    )
-    parser.add_argument(
-        "--data-dir",
-        type=Path,
-        default=DEFAULT_DATA_DIR,
-        help="Directory containing train.jsonl and eval.jsonl",
-    )
-    parser.add_argument(
-        "--output-dir",
-        type=Path,
-        default=DEFAULT_OUTPUT_DIR,
-        help="Directory to save LoRA adapter weights",
-    )
-    parser.add_argument("--epochs", type=int, default=3, help="Number of training epochs")
-    parser.add_argument("--lr", type=float, default=2e-4, help="Learning rate")
-    return parser.parse_args()
-
-
-def load_dataset(data_dir: Path):
-    """Load train/eval JSONL files as Hugging Face datasets."""
-    from datasets import load_dataset as hf_load_dataset
-
-    train_path = data_dir / "train.jsonl"
-    eval_path = data_dir / "eval.jsonl"
-
-    if not train_path.exists():
-        raise FileNotFoundError(
-            f"Training data not found at {train_path}. "
-            "Run prepare_dataset.py first."
-        )
-
-    data_files = {"train": str(train_path)}
-    if eval_path.exists():
-        data_files["eval"] = str(eval_path)
-
-    dataset = hf_load_dataset("json", data_files=data_files)
-    logger.info(
-        f"Dataset loaded — train: {len(dataset['train'])} examples"
-        + (f", eval: {len(dataset['eval'])} examples" if "eval" in dataset else "")
-    )
-    return dataset
-
-
-def format_prompt(example: dict) -> dict:
-    """Convert instruction/input/output dict to a single formatted text field.
-
-    Uses the Mistral instruct template: [INST] system + user [/INST] assistant
-    """
-    prompt = (
-        f"[INST] {example['instruction']}\n\n{example['input']} [/INST] "
-        f"{example['output']}"
-    )
-    return {"text": prompt}
-
-
-def main() -> None:
-    args = parse_args()
-    args.output_dir.mkdir(parents=True, exist_ok=True)
-
-    logger.info(f"Base model : {args.base_model}")
-    logger.info(f"Data dir  : {args.data_dir}")
-    logger.info(f"Output dir : {args.output_dir}")
-    logger.info(f"Epochs     : {args.epochs}  LR: {args.lr}")
-
-    # Lazy imports — unsloth rewrites CUDA kernels at import time
-    from unsloth import FastLanguageModel
-    from trl import SFTTrainer
-    from transformers import TrainingArguments
-
-    # Load 4-bit quantized base model
-    model, tokenizer = FastLanguageModel.from_pretrained(
-        model_name=args.base_model,
-        max_seq_length=2048,
-        dtype=None,       # auto-detect: float16 on Ampere+
-        load_in_4bit=True,
-    )
-    logger.info("Base model loaded")
-
-    # Apply LoRA adapters
-    model = FastLanguageModel.get_peft_model(
-        model,
-        r=16,
-        lora_alpha=32,
-        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
-        lora_dropout=0.05,
-        bias="none",
-        use_gradient_checkpointing="unsloth",
-        random_state=42,
-    )
-    logger.info("LoRA adapters applied")
-
-    dataset = load_dataset(args.data_dir)
-    dataset = dataset.map(format_prompt)
-
-    training_args = TrainingArguments(
-        output_dir=str(args.output_dir),
-        num_train_epochs=args.epochs,
-        per_device_train_batch_size=1,
-        gradient_accumulation_steps=4,
-        warmup_steps=10,
-        learning_rate=args.lr,
-        fp16=True,
-        logging_steps=10,
-        save_strategy="epoch",
-        eval_strategy="epoch" if "eval" in dataset else "no",
-        load_best_model_at_end=("eval" in dataset),
-        report_to="none",
-    )
-
-    trainer = SFTTrainer(
-        model=model,
-        tokenizer=tokenizer,
-        train_dataset=dataset["train"],
-        eval_dataset=dataset.get("eval"),
-        dataset_text_field="text",
-        max_seq_length=2048,
-        args=training_args,
-    )
-
-    logger.info("Starting training...")
-    trainer.train()
-
-    model.save_pretrained(str(args.output_dir))
-    tokenizer.save_pretrained(str(args.output_dir))
-    logger.info(f"Adapter weights saved to {args.output_dir}")
-    logger.info("Next step: run export_gguf.py to merge and export to GGUF")
-
-
-if __name__ == "__main__":
-    main()