code/src/agents/reranker.py

"""
Jina Reranker v3 adapter for document relevance grading.

Two backends selectable via RERANKER_BACKEND env var:
  local — loads jinaai/jina-reranker-v3 locally via transformers (free, needs ~2 GB RAM/VRAM)
  api   — calls https://api.jina.ai/v1/rerank (requires JINA_API_KEY)

Both backends expose the same .grade() / .rerank() interface so the caller
(make_grade_documents) doesn't need to know which backend is active.
"""

from __future__ import annotations

import logging
import os
from typing import Any, Dict, List, Optional, Tuple

logger = logging.getLogger(__name__)

_DEFAULT_MODEL = os.getenv("RERANKER_MODEL", "jinaai/jina-reranker-v3")
_DEFAULT_THRESHOLD = float(os.getenv("RERANKER_THRESHOLD", "0.5"))
_DEFAULT_BACKEND = os.getenv("RERANKER_BACKEND", "local")  # "local" | "api"
_NORMALIZE_SCORES = os.getenv("RERANKER_NORMALIZE", "true").lower() == "true"
_MAX_DOC_CHARS = 2000  # truncate per doc to avoid token overflow


def _sigmoid(x: float) -> float:
    """Map logit score → [0, 1] so threshold=0.5 is the natural decision boundary."""
    import math
    return 1.0 / (1.0 + math.exp(-x))


class JinaRerankerV3:
    """
    Wraps Jina Reranker v3 for (query, docs) relevance scoring.

    Usage:
        reranker = JinaRerankerV3()
        scored_docs, relevant_count = reranker.grade(query, docs)
    """

    def __init__(
        self,
        backend: str = _DEFAULT_BACKEND,
        model_name: str = _DEFAULT_MODEL,
        api_key: Optional[str] = None,
        threshold: float = _DEFAULT_THRESHOLD,
        normalize: bool = _NORMALIZE_SCORES,
        device: Optional[str] = None,
    ) -> None:
        self.backend = backend
        self.threshold = threshold
        self.normalize = normalize   # if True, apply sigmoid so threshold=0.5 is neutral
        self._model: Any = None

        if backend == "local":
            self._load_local(model_name, device)
        elif backend == "api":
            self._api_key = api_key or os.getenv("JINA_API_KEY", "")
            self._api_url = "https://api.jina.ai/v1/rerank"
            self._api_model = "jina-reranker-v3"
            if not self._api_key:
                raise ValueError("JINA_API_KEY is required for backend='api'")
            logger.info("Jina Reranker v3 API backend ready")
        else:
            raise ValueError(f"Unknown reranker backend: {backend!r}. Use 'local' or 'api'.")

    def _load_local(self, model_name: str, device: Optional[str]) -> None:
        import torch
        from transformers import AutoModel

        if device is None:
            device = "cuda" if torch.cuda.is_available() else "cpu"

        logger.info("Loading Jina Reranker v3 (%s) on %s …", model_name, device)
        self._model = AutoModel.from_pretrained(
            model_name,
            dtype="auto",
            trust_remote_code=True,
        )
        self._model.eval()
        self._model.to(device)
        logger.info("Jina Reranker v3 local backend ready ✓  (device=%s)", device)

    # ── Public interface ────────────────────────────────────────────────────────

    def rerank(
        self,
        query: str,
        docs: List[Dict],
        top_n: Optional[int] = None,
    ) -> List[Dict]:
        """
        Score and sort docs by relevance to query.

        Returns a new list of doc dicts (sorted descending by score) with
        'rerank_score' field added. Original dicts are not mutated.
        """
        if not docs:
            return []

        texts = [d.get("text", "")[:_MAX_DOC_CHARS] for d in docs]

        if self.backend == "local":
            return self._rerank_local(query, texts, docs, top_n)
        else:
            return self._rerank_api(query, texts, docs, top_n)

    def grade(
        self,
        query: str,
        docs: List[Dict],
        threshold: Optional[float] = None,
    ) -> Tuple[List[Dict], int]:
        """
        Rerank docs and count how many are relevant (score >= threshold).

        Returns (reranked_docs, relevant_count).
        Use reranked_docs as the new retrieved_docs so the generator
        always sees the best documents first.
        """
        th = threshold if threshold is not None else self.threshold
        scored = self.rerank(query, docs)
        relevant = sum(1 for d in scored if d.get("rerank_score", 0.0) >= th)
        logger.info(
            "Reranker grade: %d/%d relevant (threshold=%.2f, top_score=%.4f)",
            relevant,
            len(scored),
            th,
            scored[0]["rerank_score"] if scored else 0.0,
        )
        return scored, relevant

    # ── Backend implementations ─────────────────────────────────────────────────

    def _norm(self, score: float) -> float:
        return _sigmoid(score) if self.normalize else score

    def _rerank_local(
        self,
        query: str,
        texts: List[str],
        docs: List[Dict],
        top_n: Optional[int],
    ) -> List[Dict]:
        results = self._model.rerank(query, texts, top_n=top_n)
        scored: List[Dict] = []
        for r in results:
            doc = dict(docs[r["index"]])
            doc["rerank_score"] = self._norm(float(r["relevance_score"]))
            scored.append(doc)
        # re-sort after normalization (order preserved since sigmoid is monotone)
        return sorted(scored, key=lambda d: d["rerank_score"], reverse=True)

    def _rerank_api(
        self,
        query: str,
        texts: List[str],
        docs: List[Dict],
        top_n: Optional[int],
    ) -> List[Dict]:
        import requests

        payload: Dict = {
            "model": self._api_model,
            "query": query,
            "documents": texts,
            "return_documents": False,
        }
        if top_n is not None:
            payload["top_n"] = top_n

        resp = requests.post(
            self._api_url,
            headers={"Authorization": f"Bearer {self._api_key}", "Content-Type": "application/json"},
            json=payload,
            timeout=30,
        )
        resp.raise_for_status()
        data = resp.json()

        sorted_results = sorted(data["results"], key=lambda x: x["relevance_score"], reverse=True)
        scored: List[Dict] = []
        for r in sorted_results:
            doc = dict(docs[r["index"]])
            doc["rerank_score"] = self._norm(float(r["relevance_score"]))
            scored.append(doc)
        return scored


def load_reranker() -> Optional[JinaRerankerV3]:
    """
    Load the reranker based on environment config. Returns None on failure
    so callers can fall back to LLM grading gracefully.

    Set GRADE_BACKEND=llm to skip reranker entirely.
    """
    from src.agents.agent_config import GRADE_BACKEND, RERANKER_BACKEND, RERANKER_MODEL, RERANKER_THRESHOLD

    if GRADE_BACKEND != "reranker":
        logger.info("GRADE_BACKEND=%s — reranker disabled, using LLM grading", GRADE_BACKEND)
        return None

    normalize = os.getenv("RERANKER_NORMALIZE", "true").lower() == "true"
    try:
        return JinaRerankerV3(
            backend=RERANKER_BACKEND,
            model_name=RERANKER_MODEL,
            threshold=RERANKER_THRESHOLD,
            normalize=normalize,
        )
    except Exception as e:
        logger.warning("Reranker load failed: %s — falling back to LLM grading", e)
        return None