File size: 7,557 Bytes
27f6252 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 | """
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
|