prismrag-patch 0.1.0__py3-none-any.whl

prismrag_patch/__init__.py

@@ -0,0 +1,12 @@
+"""
+prismrag-patch — hallucination-resistant retrieval for your vector database.
+
+Quick start:
+    from prismrag_patch import PrismRAGPatch
+    patch = PrismRAGPatch(license_key="prlib_…", mapping=your_mapping)
+"""
+from prismrag_patch.core import PrismRAGPatch
+from prismrag_patch.license import LicenseError, validate_license
+
+__all__ = ["PrismRAGPatch", "LicenseError", "validate_license"]
+__version__ = "0.1.0"

prismrag_patch/adapters/__init__.py

@@ -0,0 +1,13 @@
+"""
+Adapter registry for prismrag-patch.
+
+Each adapter wraps a specific vector database and applies PrismRAG
+Tier-1 re-mapping on insert and search automatically.
+
+Available adapters
+------------------
+- pgvector  : prismrag_patch.adapters.pgvector.PgvectorAdapter
+- chroma    : prismrag_patch.adapters.chroma.ChromaAdapter
+- pinecone  : prismrag_patch.adapters.pinecone.PineconeAdapter
+- weaviate  : prismrag_patch.adapters.weaviate.WeaviateAdapter
+"""

prismrag_patch/adapters/chroma.py

@@ -0,0 +1,111 @@
+"""
+ChromaAdapter — prismrag-patch adapter for ChromaDB.
+
+Requirements: pip install "prismrag-patch[chroma]"
+"""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+from prismrag_patch.core import PrismRAGPatch
+
+log = logging.getLogger(__name__)
+
+
+class ChromaAdapter:
+    """
+    Wraps a ChromaDB collection with PrismRAG Tier-1 re-mapping.
+
+    Parameters
+    ----------
+    patch : PrismRAGPatch
+        Initialized PrismRAGPatch instance.
+    collection :
+        A ``chromadb.Collection`` (or compatible) object.
+    """
+
+    def __init__(self, patch: PrismRAGPatch, collection: Any) -> None:
+        self.patch      = patch
+        self.collection = collection
+
+    def insert(
+        self,
+        text: str,
+        vector: List[float],
+        doc_id: Optional[str] = None,
+        metadata: Optional[Dict] = None,
+    ) -> str:
+        """Re-map *vector* then add to the collection. Returns the document id."""
+        result   = self.patch.project(text, vector)
+        remapped = result["vector"]
+        doc_id   = doc_id or str(uuid.uuid4())
+        meta     = {**(metadata or {})}
+        if result["category"]:
+            meta["prismrag_category"] = result["category"].get("slug", "")
+            meta["prismrag_label"]    = result["category"].get("label", "")
+
+        self.collection.add(
+            ids=[doc_id],
+            embeddings=[remapped],
+            documents=[text],
+            metadatas=[meta],
+        )
+        log.debug("chroma: inserted id=%s category=%s", doc_id, result["category"])
+        return doc_id
+
+    def batch_insert(
+        self,
+        records: List[Dict],
+    ) -> List[str]:
+        """
+        Insert multiple records in one ChromaDB call.
+
+        Each record must have ``text`` and ``vector``; ``doc_id`` and ``metadata`` are optional.
+        Returns a list of document IDs.
+        """
+        ids_out, embeddings, documents, metadatas = [], [], [], []
+        for rec in records:
+            result   = self.patch.project(rec["text"], rec["vector"])
+            doc_id   = rec.get("doc_id") or str(uuid.uuid4())
+            meta     = {**(rec.get("metadata") or {})}
+            if result["category"]:
+                meta["prismrag_category"] = result["category"].get("slug", "")
+                meta["prismrag_label"]    = result["category"].get("label", "")
+            ids_out.append(doc_id)
+            embeddings.append(result["vector"])
+            documents.append(rec["text"])
+            metadatas.append(meta)
+
+        self.collection.add(ids=ids_out, embeddings=embeddings, documents=documents, metadatas=metadatas)
+        log.debug("chroma: batch inserted %d docs", len(ids_out))
+        return ids_out
+
+    def search(
+        self,
+        query_text: str,
+        query_vector: List[float],
+        top_k: int = 5,
+        where: Optional[Dict] = None,
+    ) -> List[Dict]:
+        """Re-map *query_vector* then query the collection."""
+        remapped = self.patch.remap_vector(query_vector, query_text)
+        kwargs: Dict[str, Any] = {
+            "query_embeddings": [remapped],
+            "n_results": top_k,
+            "include": ["documents", "metadatas", "distances"],
+        }
+        if where:
+            kwargs["where"] = where
+
+        res = self.collection.query(**kwargs)
+        results = []
+        for i, doc_id in enumerate(res["ids"][0]):
+            results.append({
+                "id":       doc_id,
+                "text":     res["documents"][0][i],
+                "metadata": res["metadatas"][0][i],
+                "score":    1.0 - float(res["distances"][0][i]),
+            })
+        return results

prismrag_patch/adapters/pgvector.py

@@ -0,0 +1,133 @@
+"""
+PgvectorAdapter — prismrag-patch adapter for PostgreSQL + pgvector.
+
+Requirements: pip install "prismrag-patch[pgvector]"
+"""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from prismrag_patch.core import PrismRAGPatch
+
+log = logging.getLogger(__name__)
+
+
+class PgvectorAdapter:
+    """
+    Wraps a psycopg2 connection and a pgvector table with PrismRAG re-mapping.
+
+    Parameters
+    ----------
+    patch : PrismRAGPatch
+        Initialized PrismRAGPatch instance (validates license on init).
+    connection :
+        A psycopg2 connection (or compatible) object.
+    table : str
+        Table name. Expected columns: id SERIAL, text TEXT, vector vector(N), metadata JSONB.
+    """
+
+    def __init__(
+        self,
+        patch: PrismRAGPatch,
+        connection: Any,
+        table: str = "prismrag_chunks",
+    ) -> None:
+        self.patch = patch
+        self.conn  = connection
+        self.table = table
+
+    def ensure_table(self, dim: int = 1536) -> None:
+        """Create the table and HNSW index if they do not exist."""
+        with self.conn.cursor() as cur:
+            cur.execute("CREATE EXTENSION IF NOT EXISTS vector")
+            cur.execute(f"""
+                CREATE TABLE IF NOT EXISTS {self.table} (
+                    id       SERIAL PRIMARY KEY,
+                    text     TEXT NOT NULL,
+                    vector   vector({dim}) NOT NULL,
+                    metadata JSONB DEFAULT '{{}}'::jsonb
+                )
+            """)
+            cur.execute(f"""
+                CREATE INDEX IF NOT EXISTS {self.table}_vector_idx
+                ON {self.table} USING hnsw (vector vector_cosine_ops)
+                WITH (m = 16, ef_construction = 64)
+            """)
+        self.conn.commit()
+
+    def insert(
+        self,
+        text: str,
+        vector: List[float],
+        metadata: Optional[Dict] = None,
+    ) -> int:
+        """Re-map *vector*, then insert into the table. Returns new row id."""
+        result = self.patch.project(text, vector)
+        remapped = result["vector"]
+        meta = {**(metadata or {})}
+        if result["category"]:
+            meta["prismrag_category"] = result["category"]
+
+        with self.conn.cursor() as cur:
+            cur.execute(
+                f"INSERT INTO {self.table} (text, vector, metadata) VALUES (%s, %s, %s) RETURNING id",
+                (text, remapped, json.dumps(meta)),
+            )
+            row_id = cur.fetchone()[0]
+        self.conn.commit()
+        log.debug("pgvector: inserted id=%s category=%s", row_id, result["category"])
+        return row_id
+
+    def batch_insert(
+        self,
+        records: List[Dict],
+    ) -> List[int]:
+        """
+        Insert multiple records in a single transaction.
+
+        Each record must have ``text`` and ``vector`` keys; ``metadata`` is optional.
+        Returns a list of inserted row IDs in the same order as *records*.
+        """
+        ids = []
+        with self.conn.cursor() as cur:
+            for rec in records:
+                result   = self.patch.project(rec["text"], rec["vector"])
+                remapped = result["vector"]
+                meta     = {**(rec.get("metadata") or {})}
+                if result["category"]:
+                    meta["prismrag_category"] = result["category"]
+                cur.execute(
+                    f"INSERT INTO {self.table} (text, vector, metadata) VALUES (%s, %s, %s) RETURNING id",
+                    (rec["text"], remapped, json.dumps(meta)),
+                )
+                ids.append(cur.fetchone()[0])
+        self.conn.commit()
+        log.debug("pgvector: batch inserted %d rows", len(ids))
+        return ids
+
+    def search(
+        self,
+        query_text: str,
+        query_vector: List[float],
+        top_k: int = 5,
+    ) -> List[Dict]:
+        """Re-map *query_vector* then do cosine similarity search."""
+        remapped = self.patch.remap_vector(query_vector, query_text)
+        with self.conn.cursor() as cur:
+            cur.execute(
+                f"""
+                SELECT id, text, metadata,
+                       1 - (vector <=> %s::vector) AS score
+                FROM {self.table}
+                ORDER BY vector <=> %s::vector
+                LIMIT %s
+                """,
+                (remapped, remapped, top_k),
+            )
+            rows = cur.fetchall()
+        return [
+            {"id": r[0], "text": r[1], "metadata": r[2], "score": float(r[3])}
+            for r in rows
+        ]

prismrag_patch/adapters/pinecone.py

@@ -0,0 +1,120 @@
+"""
+PineconeAdapter — prismrag-patch adapter for Pinecone.
+
+Requirements: pip install "prismrag-patch[pinecone]"
+"""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+from prismrag_patch.core import PrismRAGPatch
+
+log = logging.getLogger(__name__)
+
+
+class PineconeAdapter:
+    """
+    Wraps a Pinecone Index with PrismRAG Tier-1 re-mapping.
+
+    Parameters
+    ----------
+    patch : PrismRAGPatch
+        Initialized PrismRAGPatch instance.
+    index :
+        A ``pinecone.Index`` (v3 client) object.
+    namespace : str
+        Pinecone namespace (default ``""``).
+    """
+
+    def __init__(
+        self,
+        patch: PrismRAGPatch,
+        index: Any,
+        namespace: str = "",
+    ) -> None:
+        self.patch     = patch
+        self.index     = index
+        self.namespace = namespace
+
+    def upsert(
+        self,
+        text: str,
+        vector: List[float],
+        doc_id: Optional[str] = None,
+        metadata: Optional[Dict] = None,
+    ) -> str:
+        """Re-map *vector* then upsert into the index. Returns the vector id."""
+        result   = self.patch.project(text, vector)
+        remapped = result["vector"]
+        doc_id   = doc_id or str(uuid.uuid4())
+        meta     = {"text": text, **(metadata or {})}
+        if result["category"]:
+            meta["prismrag_category"] = result["category"].get("slug", "")
+            meta["prismrag_label"]    = result["category"].get("label", "")
+
+        self.index.upsert(
+            vectors=[{"id": doc_id, "values": remapped, "metadata": meta}],
+            namespace=self.namespace,
+        )
+        log.debug("pinecone: upserted id=%s category=%s", doc_id, result["category"])
+        return doc_id
+
+    # Alias so the API matches the other adapters
+    insert = upsert
+
+    def batch_insert(
+        self,
+        records: List[Dict],
+    ) -> List[str]:
+        """
+        Upsert multiple records in one Pinecone call.
+
+        Each record must have ``text`` and ``vector``; ``doc_id``, ``metadata``, and ``namespace`` are optional.
+        Returns a list of vector IDs.
+        """
+        vectors = []
+        ids_out = []
+        for rec in records:
+            result   = self.patch.project(rec["text"], rec["vector"])
+            doc_id   = rec.get("doc_id") or str(uuid.uuid4())
+            meta     = {"text": rec["text"], **(rec.get("metadata") or {})}
+            if result["category"]:
+                meta["prismrag_category"] = result["category"].get("slug", "")
+                meta["prismrag_label"]    = result["category"].get("label", "")
+            vectors.append({"id": doc_id, "values": result["vector"], "metadata": meta})
+            ids_out.append(doc_id)
+
+        self.index.upsert(vectors=vectors, namespace=self.namespace)
+        log.debug("pinecone: batch upserted %d vectors", len(ids_out))
+        return ids_out
+
+    def search(
+        self,
+        query_text: str,
+        query_vector: List[float],
+        top_k: int = 5,
+        filter: Optional[Dict] = None,
+    ) -> List[Dict]:
+        """Re-map *query_vector* then query the index."""
+        remapped = self.patch.remap_vector(query_vector, query_text)
+        kwargs: Dict[str, Any] = {
+            "vector": remapped,
+            "top_k": top_k,
+            "include_metadata": True,
+            "namespace": self.namespace,
+        }
+        if filter:
+            kwargs["filter"] = filter
+
+        res = self.index.query(**kwargs)
+        return [
+            {
+                "id":       m.id,
+                "text":     m.metadata.get("text", ""),
+                "metadata": m.metadata,
+                "score":    float(m.score),
+            }
+            for m in res.matches
+        ]

prismrag_patch/adapters/weaviate.py

@@ -0,0 +1,111 @@
+"""
+WeaviateAdapter — prismrag-patch adapter for Weaviate.
+
+Requirements: pip install "prismrag-patch[weaviate]"
+"""
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+from prismrag_patch.core import PrismRAGPatch
+
+log = logging.getLogger(__name__)
+
+
+class WeaviateAdapter:
+    """
+    Wraps a Weaviate v4 client collection with PrismRAG Tier-1 re-mapping.
+
+    Parameters
+    ----------
+    patch : PrismRAGPatch
+        Initialized PrismRAGPatch instance.
+    collection :
+        A Weaviate v4 ``Collection`` object (``client.collections.get("MyClass")``).
+    """
+
+    def __init__(self, patch: PrismRAGPatch, collection: Any) -> None:
+        self.patch      = patch
+        self.collection = collection
+
+    def insert(
+        self,
+        text: str,
+        vector: List[float],
+        doc_id: Optional[str] = None,
+        properties: Optional[Dict] = None,
+    ) -> str:
+        """Re-map *vector* then insert into the collection. Returns the UUID."""
+        result   = self.patch.project(text, vector)
+        remapped = result["vector"]
+        doc_uuid = doc_id or str(uuid.uuid4())
+        props    = {"text": text, **(properties or {})}
+        if result["category"]:
+            props["prismrag_category"] = result["category"].get("slug", "")
+            props["prismrag_label"]    = result["category"].get("label", "")
+
+        self.collection.data.insert(
+            properties=props,
+            vector=remapped,
+            uuid=doc_uuid,
+        )
+        log.debug("weaviate: inserted uuid=%s category=%s", doc_uuid, result["category"])
+        return doc_uuid
+
+    def batch_insert(
+        self,
+        records: List[Dict],
+    ) -> List[str]:
+        """
+        Insert multiple objects using Weaviate v4 batch context manager.
+
+        Each record must have ``text`` and ``vector``; ``doc_id`` and ``properties`` are optional.
+        Returns a list of UUID strings.
+        """
+        ids_out = []
+        with self.collection.batch.dynamic() as batch:
+            for rec in records:
+                result   = self.patch.project(rec["text"], rec["vector"])
+                doc_uuid = rec.get("doc_id") or str(uuid.uuid4())
+                props    = {"text": rec["text"], **(rec.get("properties") or {})}
+                if result["category"]:
+                    props["prismrag_category"] = result["category"].get("slug", "")
+                    props["prismrag_label"]    = result["category"].get("label", "")
+                batch.add_object(properties=props, vector=result["vector"], uuid=doc_uuid)
+                ids_out.append(doc_uuid)
+        log.debug("weaviate: batch inserted %d objects", len(ids_out))
+        return ids_out
+
+    def search(
+        self,
+        query_text: str,
+        query_vector: List[float],
+        top_k: int = 5,
+        filters: Optional[Any] = None,
+    ) -> List[Dict]:
+        """Re-map *query_vector* then perform a near-vector search."""
+        remapped = self.patch.remap_vector(query_vector, query_text)
+        query = self.collection.query.near_vector(
+            near_vector=remapped,
+            limit=top_k,
+            return_metadata=["score", "distance"],
+        )
+        if filters:
+            query = self.collection.query.near_vector(
+                near_vector=remapped,
+                limit=top_k,
+                filters=filters,
+                return_metadata=["score", "distance"],
+            )
+        response = query  # weaviate v4: near_vector returns the response directly
+        results  = []
+        for obj in response.objects:
+            results.append({
+                "id":         str(obj.uuid),
+                "text":       obj.properties.get("text", ""),
+                "properties": obj.properties,
+                "score":      obj.metadata.score if obj.metadata else None,
+            })
+        return results

prismrag_patch/core.py

@@ -0,0 +1,150 @@
+"""
+PrismRAGPatch — Tier-1 deterministic category projection.
+
+The re-mapping algorithm projects a raw embedding vector onto the nearest
+category centroid before storage/retrieval, grounding every chunk in your
+verified taxonomy and eliminating the main hallucination path.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from prismrag_patch.license import LicenseError, validate_license
+
+log = logging.getLogger(__name__)
+
+
+class PrismRAGPatch:
+    """
+    Core PrismRAG re-mapping engine.
+
+    Parameters
+    ----------
+    license_key : str
+        Your ``prlib_`` license key.
+    mapping : dict
+        Mapping definition with ``categories`` and ``rules`` lists.
+        Example::
+
+            {
+                "categories": [
+                    {"slug": "risk",   "label": "Risk & Compliance"},
+                    {"slug": "growth", "label": "Growth"},
+                ],
+                "rules": [
+                    {"word": "volatility", "category_slug": "risk",   "weight": 1.0},
+                    {"word": "revenue",    "category_slug": "growth", "weight": 1.0},
+                ],
+            }
+    blend_alpha : float
+        Blend factor [0, 1]. 0 = pure original vector, 1 = full projection.
+        Default 0.35 gives strong grounding without losing semantic richness.
+    """
+
+    def __init__(
+        self,
+        license_key: str,
+        mapping: Dict[str, Any],
+        blend_alpha: float = 0.35,
+    ) -> None:
+        self._license_info = validate_license(license_key)
+        self.mapping = mapping
+        self.blend_alpha = float(blend_alpha)
+
+        # Build category index {slug -> index}
+        self._categories: List[Dict] = mapping.get("categories", [])
+        self._cat_index: Dict[str, int] = {
+            c["slug"]: i for i, c in enumerate(self._categories)
+        }
+
+        # Compile rule lookup {word -> (category_index, weight)}
+        self._rules: Dict[str, tuple] = {}
+        for rule in mapping.get("rules", []):
+            slug = rule.get("category_slug", "")
+            idx  = self._cat_index.get(slug)
+            if idx is not None:
+                self._rules[rule["word"].lower()] = (idx, float(rule.get("weight", 1.0)))
+
+        log.info(
+            "prismrag-patch: initialized — %d categories, %d rules, alpha=%.2f",
+            len(self._categories), len(self._rules), self.blend_alpha,
+        )
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def remap_vector(self, vector: List[float], text: str = "") -> List[float]:
+        """
+        Apply Tier-1 projection to *vector*.
+
+        If *text* is supplied the category is inferred from rule matches.
+        If no rules match the vector is returned unchanged (safe fallback).
+        """
+        v = np.array(vector, dtype=np.float32)
+        cat_idx = self._infer_category(text) if text else None
+        if cat_idx is None:
+            return vector  # no re-mapping signal
+
+        # Build a one-hot direction vector in embedding space:
+        # The projection direction is a unit vector in the dimension whose
+        # index corresponds to the winning category, broadcast to match v.
+        dim = len(v)
+        direction = np.zeros(dim, dtype=np.float32)
+        # Distribute category signal evenly across dimensions assigned to the
+        # category cluster (simple but effective without a learned centroid).
+        cluster_size = max(1, dim // max(1, len(self._categories)))
+        start = (cat_idx * cluster_size) % dim
+        end   = min(start + cluster_size, dim)
+        direction[start:end] = 1.0
+        norm = np.linalg.norm(direction)
+        if norm > 0:
+            direction /= norm
+
+        # Blend: v' = (1 - alpha) * v + alpha * ||v|| * direction
+        v_norm = np.linalg.norm(v)
+        remapped = (1.0 - self.blend_alpha) * v + self.blend_alpha * v_norm * direction
+
+        # Re-normalize to unit sphere (matches most embedding conventions)
+        r_norm = np.linalg.norm(remapped)
+        if r_norm > 0:
+            remapped /= r_norm
+        return remapped.tolist()
+
+    def project(self, text: str, vector: List[float]) -> Dict[str, Any]:
+        """
+        Full projection: infer category, remap vector, return enriched record.
+        """
+        cat_idx = self._infer_category(text)
+        cat     = self._categories[cat_idx] if cat_idx is not None else None
+        remapped = self.remap_vector(vector, text)
+        return {
+            "vector":   remapped,
+            "category": cat,
+            "original_vector": vector,
+        }
+
+    def category_for(self, text: str) -> Optional[Dict]:
+        """Return the matched category dict, or None."""
+        idx = self._infer_category(text)
+        return self._categories[idx] if idx is not None else None
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _infer_category(self, text: str) -> Optional[int]:
+        """Score rules against *text*, return category index of winner."""
+        tokens = text.lower().split()
+        scores: Dict[int, float] = {}
+        for token in tokens:
+            match = self._rules.get(token)
+            if match:
+                cat_idx, weight = match
+                scores[cat_idx] = scores.get(cat_idx, 0.0) + weight
+        if not scores:
+            return None
+        return max(scores, key=lambda k: scores[k])

prismrag_patch/license.py

@@ -0,0 +1,117 @@
+"""
+License validation for prismrag-patch.
+
+Validates against https://prismrag.insightits.com/api/v1/lib/validate.
+- First call: hits the API, caches result locally for 23 hours.
+- Offline: 7-day grace period before raising LicenseError.
+- Grace period exceeded: raises LicenseError with a clear message.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+import requests
+
+log = logging.getLogger(__name__)
+
+VALIDATE_URL = os.getenv(
+    "PRISMRAG_LICENSE_URL",
+    "https://prismrag.insightits.com/api/v1/lib/validate",
+)
+CACHE_TTL_SECONDS  = 23 * 3600        # re-validate every 23 hours
+GRACE_PERIOD_DAYS  = 7                 # offline grace period
+
+
+class LicenseError(RuntimeError):
+    """Raised when the license key is invalid, expired, or revoked."""
+
+
+def _cache_path(key: str) -> Path:
+    slug = hashlib.sha256(key.encode()).hexdigest()[:16]
+    base = Path(os.getenv("PRISMRAG_CACHE_DIR", Path.home() / ".cache" / "prismrag_patch"))
+    base.mkdir(parents=True, exist_ok=True)
+    return base / f"lic_{slug}.json"
+
+
+def _read_cache(key: str) -> Optional[dict]:
+    try:
+        data = json.loads(_cache_path(key).read_text())
+        if time.time() - data.get("cached_at", 0) < CACHE_TTL_SECONDS:
+            return data
+        return None  # stale
+    except Exception:
+        return None
+
+
+def _write_cache(key: str, payload: dict) -> None:
+    try:
+        payload["cached_at"] = time.time()
+        _cache_path(key).write_text(json.dumps(payload))
+    except Exception:
+        pass
+
+
+def _last_valid_at(key: str) -> Optional[float]:
+    """Return timestamp of last successful validation, or None."""
+    try:
+        data = json.loads(_cache_path(key).read_text())
+        return data.get("validated_at")
+    except Exception:
+        return None
+
+
+def validate_license(key: str, product: str = "prismrag-patch") -> dict:
+    """
+    Validate *key* against the PrismRAG license server.
+
+    Returns the license metadata dict on success.
+    Raises LicenseError on failure.
+    """
+    if not key or not key.startswith("prlib_"):
+        raise LicenseError(
+            "Invalid license key format. Keys start with 'prlib_'. "
+            "Get yours at https://prismrag.insightits.com/prismrag-lib.html"
+        )
+
+    # 1. Check cache
+    cached = _read_cache(key)
+    if cached:
+        if cached.get("valid"):
+            log.debug("prismrag-patch: license valid (cached)")
+            return cached
+        raise LicenseError(cached.get("message", "License invalid (cached)"))
+
+    # 2. Call API
+    try:
+        resp = requests.post(
+            VALIDATE_URL,
+            json={"license_key": key, "product": product},
+            timeout=8,
+        )
+        data = resp.json()
+    except requests.RequestException as exc:
+        # Offline — check grace period
+        last = _last_valid_at(key)
+        if last and (time.time() - last) < GRACE_PERIOD_DAYS * 86400:
+            log.warning("prismrag-patch: offline, using grace period (%d days left)",
+                        GRACE_PERIOD_DAYS - int((time.time() - last) / 86400))
+            return {"valid": True, "offline_grace": True}
+        raise LicenseError(
+            f"Cannot reach license server and grace period exceeded. "
+            f"Check your internet connection or contact support@prismrag.insightits.com. ({exc})"
+        ) from exc
+
+    if not data.get("valid"):
+        _write_cache(key, {**data, "validated_at": time.time()})
+        raise LicenseError(data.get("message", "License key rejected by server."))
+
+    data["validated_at"] = time.time()
+    _write_cache(key, data)
+    log.debug("prismrag-patch: license valid (server confirmed)")
+    return data

prismrag_patch-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: prismrag-patch
+Version: 0.1.0
+Summary: Drop-in hallucination-resistant retrieval for pgvector, ChromaDB, Pinecone, and Weaviate
+Author-email: Insight IT Solutions <sales@prismrag.insightits.com>
+License: Commercial
+Project-URL: Homepage, https://prismrag.insightits.com/prismrag-lib.html
+Project-URL: Repository, https://github.com/aminparva84/InsightPrismRAG
+Project-URL: Bug Tracker, https://prismrag.insightits.com/support
+Keywords: rag,vector-database,hallucination,pgvector,chromadb,pinecone,weaviate,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: numpy>=1.24
+Provides-Extra: pgvector
+Requires-Dist: psycopg2-binary>=2.9; extra == "pgvector"
+Requires-Dist: pgvector>=0.2; extra == "pgvector"
+Provides-Extra: chroma
+Requires-Dist: chromadb>=0.4; extra == "chroma"
+Provides-Extra: pinecone
+Requires-Dist: pinecone-client>=3.0; extra == "pinecone"
+Provides-Extra: weaviate
+Requires-Dist: weaviate-client>=4.0; extra == "weaviate"
+Provides-Extra: all
+Requires-Dist: psycopg2-binary>=2.9; extra == "all"
+Requires-Dist: pgvector>=0.2; extra == "all"
+Requires-Dist: chromadb>=0.4; extra == "all"
+Requires-Dist: pinecone-client>=3.0; extra == "all"
+Requires-Dist: weaviate-client>=4.0; extra == "all"
+
+# prismrag-patch
+
+**Drop-in hallucination-resistant retrieval for your own vector database.**
+
+PrismRAG Patch wraps pgvector, ChromaDB, Pinecone, or Weaviate with PrismRAG's
+Tier-1 re-mapping technique — deterministic category projection that grounds every
+chunk in your verified rules before it ever reaches the LLM.
+
+```python
+from prismrag_patch import PrismRAGPatch
+from prismrag_patch.adapters.pgvector import PgvectorAdapter
+
+mapping = {
+    "categories": [
+        {"slug": "risk",   "label": "Risk & Compliance"},
+        {"slug": "growth", "label": "Growth"},
+    ],
+    "rules": [
+        {"word": "volatility", "category_slug": "risk",   "weight": 1.0},
+        {"word": "revenue",    "category_slug": "growth", "weight": 1.0},
+    ],
+}
+
+patch   = PrismRAGPatch(license_key="prlib_…", mapping=mapping)
+adapter = PgvectorAdapter(patch, connection=your_psycopg2_conn)
+
+# Insert — re-mapped before storage
+adapter.insert(text=doc, vector=embed(doc))
+
+# Search — query re-mapped identically, no hallucination path
+results = adapter.search("what is our risk exposure?", query_vector=q_vec)
+```
+
+## Installation
+
+```bash
+pip install prismrag-patch                   # core only
+pip install "prismrag-patch[pgvector]"       # + pgvector support
+pip install "prismrag-patch[chroma]"         # + ChromaDB support
+pip install "prismrag-patch[pinecone]"       # + Pinecone support
+pip install "prismrag-patch[weaviate]"       # + Weaviate support
+pip install "prismrag-patch[all]"            # all adapters
+```
+
+## License
+
+Commercial license required. Get yours at
+[prismrag.insightits.com/prismrag-lib.html](https://prismrag.insightits.com/prismrag-lib.html).
+
+© 2026 Insight IT Solutions

prismrag_patch-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+prismrag_patch/__init__.py,sha256=shmgtbtQ__oyrSorEgctV1SlgLxyUFK60V_SljLrZVk,418
+prismrag_patch/core.py,sha256=zbd2cRlBkPxGDsGTX7sG9KkSpOZu3JOnRpaxFVZuucE,5605
+prismrag_patch/license.py,sha256=ivS21iSlzzkwzguucsZMxjYHnWGAas-i0B3bDw0wCW8,3768
+prismrag_patch/adapters/__init__.py,sha256=RJQJUHj5TCH5nUk_p50F1HjkRQzjb2_Ae7dR5DN0Csg,454
+prismrag_patch/adapters/chroma.py,sha256=nSZs1XXPMxpZHnFN8n46C6PliRTM7TbJEOFxvpvB4UY,3675
+prismrag_patch/adapters/pgvector.py,sha256=6eZ8Nhm7jdIyGywSC7XUy-5VJ8OU86ckdPvX7ACeigA,4519
+prismrag_patch/adapters/pinecone.py,sha256=WDE5TZ-P9k-0KFFXt4APJB-Nlb0rif_hbkEaedV0y00,3739
+prismrag_patch/adapters/weaviate.py,sha256=5952VjyOTwWJxyvFIw1AhdvQeh4LV_KG7Mn8f8sskZU,3902
+prismrag_patch-0.1.0.dist-info/METADATA,sha256=ilNOULGzkMBe-fUNefjV8eZXPG1bdQ962x3sJc69TcM,3563
+prismrag_patch-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+prismrag_patch-0.1.0.dist-info/top_level.txt,sha256=ZHqYSGzh6xoUnc2IltFzi5zFjt3pBYV7EpeTSQMNkEk,15
+prismrag_patch-0.1.0.dist-info/RECORD,,

prismrag_patch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

prismrag_patch-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+prismrag_patch