File size: 5,552 Bytes
9a5787d | 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 | #!/usr/bin/env python3
"""embed_models.py — pluggable embedding-model factory for copernicus-rag.
The corpus vectors and the query vectors MUST come from the same model:
querying a gemini-768 corpus with a different embedder returns garbage.
rag_server guards this by comparing the embedder dim to the collection's
dense size and degrading to BM25-only on mismatch — but a real swap means
re-embedding the corpus first (see RAG/REBUILD.md §A).
Select the model with the EMBED_MODEL env var:
gemini default; gemini-embedding-2-preview, 768d
(API key via search.resolve_key)
fastembed:<model_name> local ONNX via fastembed (no torch), e.g.
fastembed:BAAI/bge-small-en-v1.5 (384d)
fastembed:BAAI/bge-base-en-v1.5 (768d)
fastembed:intfloat/multilingual-e5-large (1024d)
st:<model_name> sentence-transformers (optional dep), e.g.
st:intfloat/e5-base-v2
Every embedder L2-normalizes its output (cosine parity with the indexes).
"""
from __future__ import annotations
import os
import threading
from abc import ABC, abstractmethod
from functools import lru_cache
import numpy as np
def _l2(v: np.ndarray) -> list[float]:
n = float(np.linalg.norm(v))
return (v / n).tolist() if n > 0 else v.tolist()
class EmbeddingModel(ABC):
"""One embedding model: identity (name/dim) + query/doc encoders."""
name: str
dim: int
@abstractmethod
def embed_query(self, text: str) -> list[float]: ...
@abstractmethod
def embed_docs(self, texts: list[str]) -> list[list[float]]: ...
class GeminiEmbedding(EmbeddingModel):
"""gemini-embedding-2-preview via google-genai (the corpus default)."""
MODEL = "gemini-embedding-2-preview"
def __init__(self, dim: int = 768):
self.name = f"gemini:{self.MODEL}"
self.dim = dim
self._client = None
self._lock = threading.Lock()
def _cli(self):
if self._client is None:
with self._lock:
if self._client is None:
from google import genai
import search as S # key resolution lives with the server
self._client = genai.Client(api_key=S.resolve_key())
return self._client
def _embed(self, texts: list[str], task: str) -> list[list[float]]:
from google.genai import types
cfg = types.EmbedContentConfig(task_type=task,
output_dimensionality=self.dim)
out = []
for t in texts: # batch contents returns ONE vector — embed per item
r = self._cli().models.embed_content(model=self.MODEL, contents=t,
config=cfg)
out.append(_l2(np.array(list(r.embeddings[0].values),
dtype=np.float32)))
return out
def embed_query(self, text: str) -> list[float]:
return self._embed([text], "RETRIEVAL_QUERY")[0]
def embed_docs(self, texts: list[str]) -> list[list[float]]:
return self._embed(texts, "RETRIEVAL_DOCUMENT")
class FastEmbedModel(EmbeddingModel):
"""Local ONNX embedder via fastembed (already a dependency; no torch)."""
def __init__(self, model_name: str):
from fastembed import TextEmbedding
self._m = TextEmbedding(model_name)
self.name = f"fastembed:{model_name}"
self.dim = len(next(iter(self._m.embed(["probe"]))))
def embed_query(self, text: str) -> list[float]:
fn = getattr(self._m, "query_embed", self._m.embed)
return _l2(np.asarray(next(iter(fn([text]))), dtype=np.float32))
def embed_docs(self, texts: list[str]) -> list[list[float]]:
fn = getattr(self._m, "passage_embed", self._m.embed)
return [_l2(np.asarray(v, dtype=np.float32)) for v in fn(texts)]
class SentenceTransformersModel(EmbeddingModel):
"""sentence-transformers embedder (optional dependency, torch-based)."""
def __init__(self, model_name: str):
from sentence_transformers import SentenceTransformer
self._m = SentenceTransformer(model_name)
self.name = f"st:{model_name}"
self.dim = int(self._m.get_sentence_embedding_dimension())
# e5-family expects "query: "/"passage: " prefixes
self._e5 = "e5" in model_name.lower()
def embed_query(self, text: str) -> list[float]:
t = f"query: {text}" if self._e5 else text
return self._m.encode(t, normalize_embeddings=True).tolist()
def embed_docs(self, texts: list[str]) -> list[list[float]]:
ts = [f"passage: {t}" for t in texts] if self._e5 else texts
return self._m.encode(ts, normalize_embeddings=True).tolist()
@lru_cache(maxsize=None)
def get_embedder(spec: str | None = None) -> EmbeddingModel:
"""Factory: resolve an EmbeddingModel from a spec string or EMBED_MODEL env."""
spec = (spec or os.environ.get("EMBED_MODEL") or "gemini").strip()
if spec == "gemini" or spec.startswith("gemini:"):
return GeminiEmbedding()
if spec.startswith("fastembed:"):
return FastEmbedModel(spec.split(":", 1)[1])
if spec.startswith("st:"):
return SentenceTransformersModel(spec.split(":", 1)[1])
raise ValueError(
f"unknown EMBED_MODEL spec {spec!r} — use 'gemini', "
"'fastembed:<model>' or 'st:<model>'")
|