Datasets:

DuyTa
/

cve-kgrag-db

"""
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

	"""
	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