code/src/generators/rag_system.py

#!/usr/bin/env python3
"""
CVE-KGRAG — Hybrid RAG System (Qdrant + BM25 sparse vectors)

Backends
--------
- Dense vectors : microsoft/harrier-oss-v1-270m (640-dim, MTEB 66.5)
- Sparse vectors: BM25 (built from corpus via BM25SparseEncoder)
- Retrieval     : Qdrant RRF fusion (prefetch dense + sparse → rank)
- Collections   : cve_chunks | mitre_techniques | capec_patterns | cwe_entries

Usage
-----
  Build index (all collections):
    python -m src.generators.rag_system --build

  Search CVEs:
    python -m src.generators.rag_system --search "Log4j JNDI injection"

  Cross-collection search:
    python -m src.generators.rag_system --search "T1059" --collection mitre
"""

from __future__ import annotations

import argparse
import gc
import json
import logging
import os
import uuid
from typing import Any, Dict, List, Optional, Tuple

import numpy as np
import torch
from sentence_transformers import SentenceTransformer
from tqdm import tqdm

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, FieldCondition, Filter, Fusion, FusionQuery,
    MatchValue, NamedSparseVector, NamedVector,
    PointStruct, Prefetch, SparseVector,
    SparseVectorParams, VectorParams, VectorsConfig,
)

from src.generators.rag_config import (
    DENSE_VECTOR_NAME, DENSE_VECTOR_SIZE, DEVICE, EMBEDDING_BATCH_SIZE,
    LOGGING_LEVEL, MAX_SEQ_LENGTH, EMBEDDING_MODEL_NAME,
    QDRANT_API_KEY, QDRANT_COLLECTIONS, QDRANT_URL,
    SPARSE_VECTOR_NAME, CVE_YEAR_PATHS,
    CVE_CHUNKS_PATH, MITRE_CHUNKS_PATH, CAPEC_CHUNKS_PATH, CWE_CHUNKS_PATH,
)
from src.generators.sparse_encoder import BM25SparseEncoder

logging.basicConfig(level=LOGGING_LEVEL)
logger = logging.getLogger(__name__)


# ─────────────────────────────────────────────────────────────────────────────
# Utilities
# ─────────────────────────────────────────────────────────────────────────────

def _stable_uuid(chunk_id: str) -> str:
    """Deterministic UUID from a string chunk ID (Qdrant requires UUID or uint64)."""
    return str(uuid.uuid5(uuid.NAMESPACE_DNS, chunk_id))


def _load_chunks(path: str) -> List[Dict[str, Any]]:
    if not os.path.exists(path):
        logger.error(f"Chunks file not found: {path}. Run export_kg_for_rag_direct.py first.")
        return []
    with open(path, encoding="utf-8") as f:
        return json.load(f)


def _iter_chunks(path: str):
    """Streaming iterator over a JSON array file — avoids loading gigabytes into RAM."""
    import ijson
    if not os.path.exists(path):
        logger.error(f"Chunks file not found: {path}")
        return
    with open(path, "rb") as f:
        yield from ijson.items(f, "item")


# ─────────────────────────────────────────────────────────────────────────────
# Embedding generator
# ─────────────────────────────────────────────────────────────────────────────

class EmbeddingGenerator:
    def __init__(self) -> None:
        logger.info(f"Loading embedding model: {EMBEDDING_MODEL_NAME} on {DEVICE}")
        self.model = SentenceTransformer(EMBEDDING_MODEL_NAME)
        self.model.to(DEVICE)
        self.model.max_seq_length = MAX_SEQ_LENGTH

    def encode(self, texts: List[str], batch_size: int = EMBEDDING_BATCH_SIZE) -> np.ndarray:
        all_embs: List[np.ndarray] = []
        ctx = torch.cuda.amp.autocast() if DEVICE == "cuda" else torch.no_grad()
        for i in tqdm(range(0, len(texts), batch_size), desc="Embedding"):
            batch = texts[i : i + batch_size]
            with ctx:
                embs = self.model.encode(
                    batch,
                    convert_to_tensor=True,
                    show_progress_bar=False,
                    normalize_embeddings=True,
                )
            all_embs.append(embs.cpu().numpy())
            if DEVICE == "cuda" and i % (batch_size * 10) == 0:
                torch.cuda.empty_cache()
                gc.collect()
        return np.vstack(all_embs)


# ─────────────────────────────────────────────────────────────────────────────
# Qdrant search engine
# ─────────────────────────────────────────────────────────────────────────────

class QdrantSearchEngine:
    """Manages Qdrant collections and provides hybrid dense+sparse search."""

    def __init__(self) -> None:
        self.client = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY, timeout=30)
        self._ensure_collections()

    # ── collection management ─────────────────────────────────────────────────

    def _ensure_collections(self) -> None:
        existing = {c.name for c in self.client.get_collections().collections}
        for col_name in QDRANT_COLLECTIONS.values():
            if col_name not in existing:
                self._create_collection(col_name)

    def _create_collection(self, col_name: str) -> None:
        self.client.create_collection(
            collection_name=col_name,
            vectors_config={
                DENSE_VECTOR_NAME: VectorParams(
                    size=DENSE_VECTOR_SIZE,
                    distance=Distance.COSINE,
                ),
            },
            sparse_vectors_config={
                SPARSE_VECTOR_NAME: SparseVectorParams(),
            },
        )
        logger.info(f"Created Qdrant collection: {col_name}")

    def recreate_collections(self) -> None:
        """Drop and recreate all collections (used on force rebuild)."""
        for col_name in QDRANT_COLLECTIONS.values():
            try:
                self.client.delete_collection(col_name)
                logger.info(f"Dropped collection: {col_name}")
            except Exception:
                pass
            self._create_collection(col_name)

    def collection_count(self, key: str) -> int:
        col = QDRANT_COLLECTIONS.get(key, key)
        try:
            return self.client.get_collection(col).points_count or 0
        except Exception:
            return 0

    # ── indexing ──────────────────────────────────────────────────────────────

    def upsert(
        self,
        collection_key: str,
        chunks: List[Dict[str, Any]],
        dense_vecs: np.ndarray,
        sparse_vecs: List[Dict[str, Any]],
        batch_size: int = 2000,
    ) -> None:
        col = QDRANT_COLLECTIONS[collection_key]
        total = len(chunks)
        logger.info(f"Upserting {total} points → {col}")

        for start in tqdm(range(0, total, batch_size), desc=f"Upsert {col}"):
            end = min(start + batch_size, total)
            points = []
            for i in range(start, end):
                chunk  = chunks[i]
                d_vec  = dense_vecs[i].tolist()
                s_vec  = sparse_vecs[i]
                payload= chunk.get("payload", {})

                # Sanitise payload: lists → JSON strings where needed for Qdrant
                clean_payload: Dict[str, Any] = {}
                for k, v in payload.items():
                    if isinstance(v, list):
                        clean_payload[k] = [str(x) for x in v]
                    elif v is None:
                        pass  # drop nulls
                    else:
                        clean_payload[k] = v

                points.append(
                    PointStruct(
                        id=_stable_uuid(chunk["id"]),
                        vector={
                            DENSE_VECTOR_NAME: d_vec,
                            SPARSE_VECTOR_NAME: SparseVector(
                                indices=s_vec["indices"],
                                values=s_vec["values"],
                            ),
                        },
                        payload={**clean_payload, "chunk_id": chunk["id"], "text": chunk["text"]},
                    )
                )
            self.client.upsert(collection_name=col, points=points)

        logger.info(f"Done upserting {total} points into {col}")

    # ── search ────────────────────────────────────────────────────────────────

    def search(
        self,
        collection_key: str,
        dense_vec: List[float],
        sparse_vec: Dict[str, Any],
        k: int = 10,
        filters: Optional[Dict[str, Any]] = None,
    ) -> List[Dict[str, Any]]:
        col = QDRANT_COLLECTIONS[collection_key]

        qdrant_filter = None
        if filters:
            conditions = [
                FieldCondition(key=fk, match=MatchValue(value=fv))
                for fk, fv in filters.items()
                if fv is not None
            ]
            if conditions:
                qdrant_filter = Filter(must=conditions)

        results = self.client.query_points(
            collection_name=col,
            prefetch=[
                Prefetch(
                    query=dense_vec,
                    using=DENSE_VECTOR_NAME,
                    limit=50,
                ),
                Prefetch(
                    query=SparseVector(
                        indices=sparse_vec["indices"],
                        values=sparse_vec["values"],
                    ),
                    using=SPARSE_VECTOR_NAME,
                    limit=50,
                ),
            ],
            query=FusionQuery(fusion=Fusion.RRF),
            query_filter=qdrant_filter,
            limit=k,
            with_payload=True,
        )

        formatted = []
        for point in results.points:
            payload  = point.payload or {}
            score    = point.score
            formatted.append({
                "id":       payload.get("chunk_id", str(point.id)),
                "text":     payload.get("text", ""),
                "metadata": payload,
                "score":    score,
                "distance": 1 - score,
            })
        return formatted

    def get_stats(self) -> Dict[str, Any]:
        return {
            key: self.collection_count(key)
            for key in QDRANT_COLLECTIONS
        }


# ─────────────────────────────────────────────────────────────────────────────
# Main RAG system
# ─────────────────────────────────────────────────────────────────────────────

class CVERAGSystem:
    """
    Orchestrates building and querying the hybrid Qdrant index.

    Public API (same signatures as before for API compatibility):
      build_vector_database(force_rebuild)
      search_cves(query, n_results, severity_filter, vendor_filter) → list
      get_similar_cves(cve_id, n_results) → list
      get_vulnerability_summary(query) → dict
      get_collection_stats() → dict
    """

    def __init__(self) -> None:
        self.engine  = QdrantSearchEngine()
        self._emb    = None   # lazy-loaded
        self._sparse = None   # lazy-loaded from disk

    @property
    def embedding_generator(self) -> EmbeddingGenerator:
        if self._emb is None:
            self._emb = EmbeddingGenerator()
        return self._emb

    @property
    def sparse_encoder(self) -> Optional[BM25SparseEncoder]:
        if self._sparse is None:
            self._sparse = BM25SparseEncoder.load_or_none()
        return self._sparse

    # ── build ─────────────────────────────────────────────────────────────────

    def build_vector_database(self, force_rebuild: bool = False) -> None:
        """
        Build Qdrant index for all four collections with incremental checkpointing.

        Strategy:
          1. Load small collections (MITRE/CAPEC/CWE) into RAM — they're tiny.
          2. Fit BM25 on those + a 250K sample of CVE texts, persist vocab to disk.
          3. Upsert small collections (skipped if already present and not force).
          4. Stream CVE chunks in batches of STREAM_BATCH: encode → upsert → checkpoint.
             On restart, reads checkpoint to skip already-upserted chunks by position.
        """
        STREAM_BATCH    = 2_000   # chunks per encode+upsert cycle
        CHECKPOINT_PATH = os.path.join(os.path.dirname(CVE_CHUNKS_PATH), ".cve_index_checkpoint")

        chunk_sources_small = {
            "mitre": MITRE_CHUNKS_PATH,
            "capec": CAPEC_CHUNKS_PATH,
            "cwe":   CWE_CHUNKS_PATH,
        }

        # Drop + recreate collections on force rebuild (clears wrong vector dims etc.)
        if force_rebuild:
            self.engine.recreate_collections()
            if os.path.exists(CHECKPOINT_PATH):
                os.remove(CHECKPOINT_PATH)
                logger.info("Removed CVE index checkpoint (force rebuild).")

        # ── Step 1: load small collections ───────────────────────────────────
        small: Dict[str, List[Dict[str, Any]]] = {}
        small_texts: List[str] = []
        for key, path in chunk_sources_small.items():
            chunks = _load_chunks(path)
            if not chunks:
                logger.warning(f"No chunks for {key} — skipping.")
                continue
            seen: set = set()
            unique = [c for c in chunks if c["id"] not in seen and not seen.add(c["id"])]
            logger.info(f"  {key}: {len(unique)} chunks")
            small[key] = unique
            small_texts.extend(c["text"] for c in unique)

        # ── Step 2: fit BM25 (or reload from disk) ───────────────────────────
        enc = BM25SparseEncoder.load_or_none() if not force_rebuild else None
        if enc is None:
            cve_sample: List[str] = []
            max_cve_sample = max(0, 250_000 - len(small_texts))
            if max_cve_sample > 0 and os.path.exists(CVE_CHUNKS_PATH):
                logger.info(f"Sampling up to {max_cve_sample:,} CVE texts for BM25 fit …")
                for chunk in _iter_chunks(CVE_CHUNKS_PATH):
                    cve_sample.append(chunk["text"])
                    if len(cve_sample) >= max_cve_sample:
                        break
            corpus = small_texts + cve_sample
            logger.info(f"Fitting BM25 on {len(corpus):,} texts …")
            enc = BM25SparseEncoder()
            enc.fit(corpus)
            logger.info(f"BM25 vocab size: {len(enc.vocab):,}")
            del cve_sample
        self._sparse = enc

        # ── Step 3: upsert small collections (skip if already indexed) ───────
        for key, chunks in small.items():
            if not force_rebuild and self.engine.collection_count(key) >= len(chunks):
                logger.info(f"  {key}: already indexed ({self.engine.collection_count(key)} pts), skipping.")
                continue
            texts = [c["text"] for c in chunks]
            logger.info(f"Encoding + upserting {key} ({len(texts)} chunks) …")
            dense  = self.embedding_generator.encode(texts)
            sparse = [enc.encode(t) for t in tqdm(texts, desc=f"BM25 {key}")]
            self.engine.upsert(key, chunks, dense, sparse)

        # ── Step 4: stream CVE collection with checkpoint ─────────────────────
        if not os.path.exists(CVE_CHUNKS_PATH):
            logger.warning("cve_chunks.json not found — skipping CVE index.")
        else:
            # Read checkpoint: number of stream positions already processed
            resume_pos = 0
            if os.path.exists(CHECKPOINT_PATH):
                try:
                    with open(CHECKPOINT_PATH) as f:
                        resume_pos = int(f.read().strip())
                    logger.info(f"Resuming CVE index from position {resume_pos:,}")
                except Exception:
                    resume_pos = 0

            logger.info(f"Streaming CVE chunks (batch={STREAM_BATCH:,}, skip first {resume_pos:,}) …")
            batch_chunks: List[Dict[str, Any]] = []
            seen_ids: set = set()
            total_upserted = resume_pos
            stream_pos = 0

            for chunk in _iter_chunks(CVE_CHUNKS_PATH):
                stream_pos += 1
                if stream_pos <= resume_pos:
                    continue  # fast-forward past already-indexed items

                cid = chunk.get("id", "")
                if cid in seen_ids:
                    continue
                seen_ids.add(cid)
                batch_chunks.append(chunk)

                if len(batch_chunks) >= STREAM_BATCH:
                    texts  = [c["text"] for c in batch_chunks]
                    dense  = self.embedding_generator.encode(texts)
                    sparse = [enc.encode(t) for t in texts]
                    self.engine.upsert("cve", batch_chunks, dense, sparse)
                    total_upserted += len(batch_chunks)
                    # Persist checkpoint after successful upsert
                    with open(CHECKPOINT_PATH, "w") as f:
                        f.write(str(stream_pos))
                    logger.info(f"  … {total_upserted:,} CVE chunks upserted (pos {stream_pos:,})")
                    batch_chunks = []
                    if DEVICE == "cuda":
                        torch.cuda.empty_cache()

            # Final partial batch
            if batch_chunks:
                texts  = [c["text"] for c in batch_chunks]
                dense  = self.embedding_generator.encode(texts)
                sparse = [enc.encode(t) for t in texts]
                self.engine.upsert("cve", batch_chunks, dense, sparse)
                total_upserted += len(batch_chunks)
                with open(CHECKPOINT_PATH, "w") as f:
                    f.write(str(stream_pos))

            logger.info(f"CVE indexing done: {total_upserted:,} chunks")
            # Remove checkpoint on clean finish
            if os.path.exists(CHECKPOINT_PATH):
                os.remove(CHECKPOINT_PATH)

        logger.info("Build complete. Stats: " + str(self.engine.get_stats()))

    # ── search helpers ────────────────────────────────────────────────────────

    def _encode_query(self, query: str) -> Tuple[List[float], Dict[str, Any]]:
        dense_arr = self.embedding_generator.encode([query])
        dense_vec = dense_arr[0].tolist()
        enc       = self.sparse_encoder
        sparse_vec= enc.encode_query(query) if enc else {"indices": [], "values": []}
        return dense_vec, sparse_vec

    # ── public API ────────────────────────────────────────────────────────────

    def search_cves(
        self,
        query: str,
        n_results: int = 10,
        severity_filter: Optional[str] = None,
        vendor_filter: Optional[str] = None,
        collection: str = "cve",
    ) -> List[Dict[str, Any]]:
        dense, sparse = self._encode_query(query)
        filters: Dict[str, Any] = {}
        if severity_filter:
            filters["severity"] = severity_filter
        return self.engine.search(collection, dense, sparse, k=n_results, filters=filters or None)

    def search(
        self,
        query: str,
        n_results: int = 10,
        collection: str = "cve",
        filters: Optional[Dict[str, Any]] = None,
    ) -> List[Dict[str, Any]]:
        """Generic search across any collection."""
        dense, sparse = self._encode_query(query)
        return self.engine.search(collection, dense, sparse, k=n_results, filters=filters)

    def get_similar_cves(self, cve_id: str, n_results: int = 5) -> List[Dict[str, Any]]:
        anchor = self.search_cves(f"CVE ID: {cve_id}", n_results=1)
        if not anchor:
            logger.warning(f"{cve_id} not found in index")
            return []
        anchor_text = anchor[0].get("text", f"CVE ID: {cve_id}")
        results     = self.search_cves(anchor_text, n_results=n_results + 1)
        return [r for r in results if r["metadata"].get("cve_id") != cve_id][:n_results]

    def get_vulnerability_summary(self, query: str) -> Dict[str, Any]:
        results = self.search_cves(query, n_results=50)
        if not results:
            return {"error": "No vulnerabilities found"}

        severities: Dict[str, int] = {}
        vendors:    set = set()
        products:   set = set()
        cwes:       set = set()

        for r in results:
            m = r.get("metadata", {})
            sev = m.get("severity", "Unknown")
            severities[sev] = severities.get(sev, 0) + 1
            for p in (m.get("products") or []):
                products.add(p)
            for c in (m.get("cwe_refs") or []):
                cwes.add(c)

        return {
            "query":                query,
            "total_results":        len(results),
            "severity_distribution":severities,
            "top_products":         list(products)[:10],
            "common_weaknesses":    list(cwes)[:10],
            "sample_results":       results[:5],
        }

    def get_collection_stats(self) -> Dict[str, Any]:
        stats = self.engine.get_stats()
        return {
            "total_documents": sum(stats.values()),
            "collections":     stats,
            "qdrant_url":      QDRANT_URL,
        }

    # ── legacy (year-based scan fallback) ────────────────────────────────────

    def search_cves_by_year(
        self,
        query: str,
        years: List[str] | None = None,
        n_results: int = 10,
        vendor_terms: list | None = None,
        product_terms: list | None = None,
    ) -> List[Dict[str, Any]]:
        """Fallback linear scan over year JSON files (no Qdrant)."""
        import re as _re
        years = years or ["2021", "2022", "2023", "2024"]
        vendor_terms  = vendor_terms  or []
        product_terms = product_terms or []
        query_lower   = query.lower()
        all_results: List[Dict[str, Any]] = []

        for year in years:
            path = CVE_YEAR_PATHS.get(year)
            if not path or not os.path.exists(path):
                continue
            with open(path, encoding="utf-8") as f:
                docs = json.load(f)
            for doc in docs:
                doc_vendors  = doc.get("affected_vendors",  []) or []
                doc_products = doc.get("affected_products", []) or []
                if isinstance(doc_vendors,  str): doc_vendors  = [doc_vendors]
                if isinstance(doc_products, str): doc_products = [doc_products]

                vm = any(vt.lower() in v.lower() for vt in vendor_terms  for v in doc_vendors)
                pm = any(pt.lower() in p.lower() for pt in product_terms for p in doc_products)
                if (vendor_terms or product_terms) and not (vm or pm):
                    continue
                content = doc.get("content", "").lower()
                if not (vendor_terms or product_terms) and query_lower not in content:
                    continue
                score = content.count(query_lower) / max(1, len(content))
                all_results.append({
                    "id":   doc.get("id"),
                    "text": doc.get("content", "")[:1000],
                    "metadata": {
                        "cve_id":   doc.get("id"),
                        "year":     year,
                        "severity": doc.get("cvss_v3", {}).get("base_severity", "Unknown"),
                        "cvss_score": doc.get("cvss_v3", {}).get("base_score"),
                    },
                    "score":    score,
                    "distance": 1 - score,
                })

        all_results.sort(key=lambda x: x["score"], reverse=True)
        return all_results[:n_results]


# ─────────────────────────────────────────────────────────────────────────────
# CLI
# ─────────────────────────────────────────────────────────────────────────────

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="CVE-KGRAG Hybrid RAG System")
    parser.add_argument("--build",         action="store_true", help="Build / rebuild index")
    parser.add_argument("--force",         action="store_true", help="Force full rebuild")
    parser.add_argument("--search",        type=str,            help="Search query")
    parser.add_argument("--collection",    type=str, default="cve",
                        choices=list(QDRANT_COLLECTIONS.keys()), help="Collection to search")
    parser.add_argument("--n_results",     type=int, default=5)
    parser.add_argument("--summary",       type=str,            help="Vulnerability summary query")
    args = parser.parse_args()

    rag = CVERAGSystem()

    if args.build:
        rag.build_vector_database(force_rebuild=args.force)

    elif args.search:
        results = rag.search(args.search, n_results=args.n_results, collection=args.collection)
        for i, r in enumerate(results, 1):
            m = r.get("metadata", {})
            print(f"{i}. [{m.get('cve_id', m.get('technique_id', m.get('cwe_id', r['id'])))}]"
                  f"  severity={m.get('severity', '-')}  score={r['score']:.4f}")
            print(f"   {r['text'][:200]}\n")

    elif args.summary:
        s = rag.get_vulnerability_summary(args.summary)
        print(f"Query: {s['query']}")
        print(f"Total: {s['total_results']}")
        print(f"Severity: {s['severity_distribution']}")
        print(f"Products: {s['top_products']}")
        print(f"CWEs: {s['common_weaknesses']}")

    else:
        stats = rag.get_collection_stats()
        print("Collection stats:", json.dumps(stats, indent=2))
        parser.print_help()