File size: 5,067 Bytes
0a19322
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Shared singletons: embedding model, re-ranker and the vector DB (all thread-safe)."""
import logging
import threading
from functools import lru_cache
from pathlib import Path

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance,
    FieldCondition,
    Filter,
    FilterSelector,
    MatchAny,
    PointStruct,
    VectorParams,
)

from .config import settings

log = logging.getLogger("rag.store")

__all__ = ["PointStruct"]

_qlock = threading.RLock()  # qdrant local mode is not thread-safe, so every call goes through this
_model_lock = threading.Lock()
_embedder = None
_reranker = None
_reranker_failed = False


# ---------------------------------------------------------------- embeddings
def set_embedder(obj) -> None:
    """Swap the embedder (used by tests with a fake one)."""
    global _embedder
    _embedder = obj


def get_embedder():
    global _embedder
    if _embedder is None:
        with _model_lock:
            if _embedder is None:
                from sentence_transformers import SentenceTransformer  # lazy: heavy import

                log.info("Loading embedding model %s", settings.embed_model)
                _embedder = SentenceTransformer(settings.embed_model)
    return _embedder


def embed(texts: list[str]) -> list[list[float]]:
    vecs = get_embedder().encode(texts, normalize_embeddings=True, batch_size=32, show_progress_bar=False)
    return vecs.tolist()


def embedding_dim() -> int:
    return int(get_embedder().get_sentence_embedding_dimension())


# ------------------------------------------------------------------ reranker
def get_reranker():
    """Cross-encoder used to re-rank candidates. Returns None if disabled or unavailable."""
    global _reranker, _reranker_failed
    if not settings.use_reranker or _reranker_failed:
        return None
    if _reranker is None:
        with _model_lock:
            if _reranker is None and not _reranker_failed:
                try:
                    from sentence_transformers import CrossEncoder  # lazy

                    log.info("Loading re-ranker %s", settings.rerank_model)
                    _reranker = CrossEncoder(settings.rerank_model, max_length=512)
                except Exception as e:  # no internet, blocked DLL, etc. -> degrade gracefully
                    log.warning("Re-ranker unavailable, continuing without it: %s", e)
                    _reranker_failed = True
    return _reranker


# -------------------------------------------------------------------- qdrant
def _ensure_collection(client: QdrantClient) -> None:
    existing = {c.name for c in client.get_collections().collections}
    if settings.collection not in existing:
        client.create_collection(
            collection_name=settings.collection,
            vectors_config=VectorParams(size=embedding_dim(), distance=Distance.COSINE),
        )


@lru_cache
def get_qdrant() -> QdrantClient:
    path = Path(settings.data_dir) / "qdrant"
    path.mkdir(parents=True, exist_ok=True)
    with _qlock:
        client = QdrantClient(path=str(path))
        _ensure_collection(client)
    return client


def make_filter(doc_ids=None, pages=None) -> Filter | None:
    must = []
    if doc_ids:
        must.append(FieldCondition(key="doc_id", match=MatchAny(any=list(doc_ids))))
    if pages:
        must.append(FieldCondition(key="page", match=MatchAny(any=[int(p) for p in pages])))
    return Filter(must=must) if must else None


def _hit(p) -> dict:
    return {"id": str(p.id), "score": float(getattr(p, "score", 0.0) or 0.0), **(p.payload or {})}


def upsert(points: list[PointStruct]) -> None:
    with _qlock:
        get_qdrant().upsert(collection_name=settings.collection, points=points)


def search(vector: list[float], flt: Filter | None, limit: int) -> list[dict]:
    with _qlock:
        res = get_qdrant().query_points(
            collection_name=settings.collection,
            query=vector,
            query_filter=flt,
            limit=limit,
            with_payload=True,
        )
    return [_hit(p) for p in res.points]


def scroll_all(flt: Filter | None = None) -> list[dict]:
    """Every stored chunk (payload only) that matches the filter."""
    out: list[dict] = []
    offset = None
    while True:
        with _qlock:
            points, offset = get_qdrant().scroll(
                collection_name=settings.collection,
                scroll_filter=flt,
                limit=512,
                offset=offset,
                with_payload=True,
                with_vectors=False,
            )
        out.extend(_hit(p) for p in points)
        if offset is None:
            break
    return out


def delete_doc(doc_id: str) -> None:
    with _qlock:
        get_qdrant().delete(
            collection_name=settings.collection,
            points_selector=FilterSelector(filter=make_filter([doc_id])),
        )


def clear_all() -> None:
    with _qlock:
        client = get_qdrant()
        client.delete_collection(settings.collection)
        _ensure_collection(client)