File size: 5,654 Bytes
c980379 |
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 |
#!/usr/bin/env python3
"""
Query interface for the Mixedbread CVE RAG index with reranking using Chroma DB.
"""
from __future__ import annotations
import argparse
import json
from typing import List, Sequence
import numpy as np
import chromadb
from chromadb.config import Settings as ChromaSettings
from chromadb import errors as chroma_errors
from sentence_transformers import SentenceTransformer, CrossEncoder
from .config import Settings, load_settings
class QueryEngine:
def __init__(self, settings: Settings, normalize: bool):
self.settings = settings
self.normalize = normalize
chroma_settings = ChromaSettings(
is_persistent=True,
persist_directory=str(settings.chroma_dir),
)
self.client = chromadb.Client(chroma_settings)
try:
self.collection = self.client.get_collection(settings.chroma_collection)
except chroma_errors.NotFoundError as exc:
raise FileNotFoundError(
f"Chroma collection '{settings.chroma_collection}' not found in {settings.chroma_dir}. "
"Run build_index.py first."
) from exc
# Load embedding model locally
print(f"Loading embedding model: {settings.embed_model}")
embed_kwargs = {
"device": settings.device,
}
if settings.hf_token:
embed_kwargs["use_auth_token"] = settings.hf_token
self.embed_model = SentenceTransformer(
settings.embed_model,
**embed_kwargs,
)
print(f"Loading reranker model: {settings.rerank_model}")
rerank_kwargs = {
"device": settings.device,
}
if settings.hf_token:
rerank_kwargs["token"] = settings.hf_token
self.rerank_model = CrossEncoder(
settings.rerank_model,
**rerank_kwargs,
)
print(f"Models loaded on {settings.device}")
def _embed(self, texts: Sequence[str]) -> np.ndarray:
"""Embed texts using the local model."""
embeddings = self.embed_model.encode(
list(texts),
batch_size=len(texts),
show_progress_bar=False,
normalize_embeddings=self.normalize,
convert_to_numpy=True,
)
return embeddings
def _rerank(self, query: str, candidates: List[dict], top_n: int) -> List[dict]:
"""Rerank candidates using the local CrossEncoder model."""
pairs = [[query, c["text"]] for c in candidates]
scores = self.rerank_model.predict(pairs)
scored = []
for candidate, score in zip(candidates, scores):
scored.append({**candidate, "rerank_score": float(score)})
scored.sort(key=lambda x: x.get("rerank_score", 0), reverse=True)
return scored[:top_n]
def query(self, query_text: str, top_k: int, top_n: int) -> List[dict]:
query_vec = self._embed([query_text])
results = self.collection.query(
query_embeddings=query_vec.tolist(),
n_results=top_k,
include=["documents", "metadatas", "distances"],
)
documents = results.get("documents", [[]])[0]
metadatas = results.get("metadatas", [[]])[0]
distances = results.get("distances", [[]])[0]
candidates = []
for doc, meta, score in zip(documents, metadatas, distances):
candidates.append(
{
"score": float(score),
"text": doc,
"cve_id": meta.get("cve_id", "UNKNOWN"),
"chunk_id": meta.get("chunk_id", -1),
"metadata": {k: v for k, v in meta.items() if k not in {"cve_id", "chunk_id", "text"}},
}
)
if not candidates:
return []
return self._rerank(query_text, candidates, top_n)
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Query the Mixedbread CVE index.")
parser.add_argument("query", help="Natural language query to search for.")
parser.add_argument(
"--top-k",
type=int,
default=20,
help="Number of candidates to retrieve before reranking.",
)
parser.add_argument(
"--top-n",
type=int,
default=5,
help="Number of reranked results to display.",
)
parser.add_argument(
"--normalize",
action="store_true",
help="Normalize query embeddings (must match build_index normalization).",
)
parser.add_argument(
"--json",
action="store_true",
help="Emit results as JSON for downstream automation.",
)
return parser.parse_args()
def main() -> None:
args = parse_args()
settings = load_settings()
engine = QueryEngine(settings, normalize=args.normalize)
results = engine.query(args.query, args.top_k, args.top_n)
if args.json:
print(json.dumps(results, indent=2))
return
for idx, result in enumerate(results, start=1):
print(f"[{idx}] CVE {result['cve_id']} (chunk {result['chunk_id']})")
print(f" Rerank score: {result.get('rerank_score'):.4f}")
meta = result["metadata"]
if meta.get("cwe"):
print(f" CWE: {meta['cwe']}")
if meta.get("published"):
print(f" Published: {meta['published']}")
print(" Text preview:")
preview = result["text"].strip().replace("\n", " ")
print(f" {preview[:400]}{'...' if len(preview) > 400 else ''}")
print()
if __name__ == "__main__":
main()
|