quasar-context 0.1.0__tar.gz

quasar_context-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sebastian Sabo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quasar_context-0.1.0/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: quasar-context
+Version: 0.1.0
+Summary: Faithful context optimization for RAG apps — compress without corrupting critical data
+Author: Sebastian Sabo
+License: MIT
+Project-URL: Homepage, https://github.com/sebastiansabo/quasar
+Project-URL: Issues, https://github.com/sebastiansabo/quasar/issues
+Keywords: rag,llm,context,compression,prompt,embeddings
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: tiktoken>=0.5.0
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# Quasar
+
+**Faithful context optimization for RAG apps.**
+
+Compress retrieved context before your LLM call — without silently corrupting the
+values that matter. Prices, IBANs, dates, invoice numbers, legal references and
+IDs are preserved **verbatim** when the budget allows. When it doesn't, Quasar
+**tells you** instead of quietly dropping them.
+
+```python
+from quasar import ContextOptimizer
+
+opt = ContextOptimizer()
+result = opt.optimize(query, retrieved_chunks, target_tokens=500)
+
+llm_answer(query, result.context)      # feed the compressed context
+print(result.report.summary())
+# [Quasar] 63% smaller (1284->475 tok, ~$0.0024 saved) | critical 7/7 OK
+```
+
+---
+
+## Why this exists
+
+Every context compressor optimizes for one thing: fewer tokens. None of them tell
+you what they destroyed on the way.
+
+If your RAG app retrieves an invoice and the compressor drops or mangles
+`€47,350.00`, your LLM confidently answers with the wrong number and **you never
+find out**. That's fine for a chatbot. It is not fine for finance, legal,
+medical, compliance, or code.
+
+Quasar makes one guarantee no other compressor makes:
+
+> **It never silently corrupts your critical data.**
+> Critical values survive verbatim, or you get an explicit warning.
+
+---
+
+## What it does
+
+1. **Detects critical spans** — currency, IBANs, dates, VINs, long IDs, legal
+   references, contract codes — by pattern.
+2. **Reserves them verbatim.** Critical sentences claim budget first and are
+   never rewritten. (Token-deletion compressors *rewrite* text — that's how they
+   corrupt exact values.)
+3. **Fills the remaining budget by relevance**, using embedding similarity to the
+   query. Filler is dropped.
+4. **Dedupes** repeated sentences so budget isn't wasted on copies.
+5. **Audits and reports.** Every call returns tokens saved, cost saved, and a
+   faithfulness status — with warnings naming any critical value it couldn't fit.
+
+---
+
+## Honest benchmarks
+
+Measured on LongBench (narrativeqa / qasper / hotpotqa, N=30 per task), real LLM
+judge, token-F1 scoring.
+
+**Where Quasar wins:**
+
+| Matchup | Result |
+|---|---|
+| vs **truncation** | **9–0** — wins at every task and budget |
+| vs **LLMLingua** | **6–0** on accuracy, **8–13× faster** to compress |
+| Long contexts | Handles 17k+ word documents LLMLingua **cannot process at all** |
+
+LLMLingua runs a neural model to compress. Quasar runs embeddings. Same or better
+accuracy, a fraction of the compute.
+
+**Where Quasar does not win — stated plainly:**
+
+Against a **pure top-k embedding filter** (e.g. LangChain's `EmbeddingsFilter`),
+Quasar goes **3–6** on raw QA accuracy. On pure question-answering, simple
+relevance ranking is competitive or better.
+
+**So Quasar is not the accuracy leader on QA, and doesn't claim to be.** Its value
+is the axis those benchmarks don't measure: *faithfulness*. A top-k filter has no
+concept of critical data — it drops a low-relevance sentence containing your
+invoice number without hesitation, and never tells you. Quasar reserves it, and
+warns when it can't.
+
+**Use Quasar when correctness of exact values matters more than the last 2% of
+retrieval F1.** If you're building a general chatbot and only care about QA
+accuracy, use a top-k filter — it's simpler and we'll say so.
+
+---
+
+## Install
+
+```bash
+pip install quasar-context
+```
+
+## Usage
+
+### Basic
+
+```python
+from quasar import ContextOptimizer
+
+opt = ContextOptimizer()          # loads the embedding model once
+result = opt.optimize(
+    query="What is the total due and the deadline?",
+    context=retrieved_chunks,     # str or list[str]
+    target_tokens=500,
+)
+
+result.context                    # compressed text for your LLM
+result.report.tokens_saved        # int
+result.report.faithful            # bool — did all critical values survive?
+result.report.warnings            # list[str] — what got dropped and why
+```
+
+### Guarding a production call
+
+```python
+result = opt.optimize(query, chunks, target_tokens=500)
+
+if not result.report.faithful:
+    # budget too tight to hold every critical value — your call:
+    logger.warning("Quasar: %s", result.report.warnings)
+    result = opt.optimize(query, chunks, target_tokens=1000)   # give it room
+
+answer = llm(query, result.context)
+```
+
+### Configuration
+
+```python
+from quasar import ContextOptimizer, OptimizerConfig
+
+opt = ContextOptimizer(OptimizerConfig(
+    cost_per_1k_tokens=0.003,   # your model's price, for the savings report
+    preserve_critical=True,     # the faithfulness behavior (default on)
+    min_relevance=0.05,         # drop sentences below this query relevance
+    model_name="all-MiniLM-L6-v2",
+))
+```
+
+### Custom critical patterns
+
+Your domain has its own critical formats. Add them:
+
+```python
+from quasar import core
+core._CRITICAL_PATTERNS.append((r"\bCASE-\d{6}\b", "case_id"))
+```
+
+---
+
+## Performance
+
+- **~10–100 ms per call** after warm-up (embedding + greedy selection).
+- **First call loads the model** (~30–60s, one time). Warm it at startup:
+  ```python
+  opt = ContextOptimizer()
+  opt.optimize("warmup", "warmup text.", target_tokens=50)
+  ```
+- **8–13× faster than LLMLingua**, which runs a full neural model to compress.
+
+---
+
+## What Quasar is not
+
+- **Not the best compressor by ratio.** Token-deletion methods compress harder.
+  They also rewrite your text.
+- **Not an accuracy leader on pure QA.** A top-k filter matches or beats it there.
+- **Not a guarantee against physics.** If your critical content is larger than
+  your token budget, it cannot all fit. Quasar preserves what it can *and tells
+  you what it couldn't* — that's the honest contract.
+
+---
+
+## License
+
+MIT.

quasar_context-0.1.0/README.md

@@ -0,0 +1,177 @@
+# Quasar
+
+**Faithful context optimization for RAG apps.**
+
+Compress retrieved context before your LLM call — without silently corrupting the
+values that matter. Prices, IBANs, dates, invoice numbers, legal references and
+IDs are preserved **verbatim** when the budget allows. When it doesn't, Quasar
+**tells you** instead of quietly dropping them.
+
+```python
+from quasar import ContextOptimizer
+
+opt = ContextOptimizer()
+result = opt.optimize(query, retrieved_chunks, target_tokens=500)
+
+llm_answer(query, result.context)      # feed the compressed context
+print(result.report.summary())
+# [Quasar] 63% smaller (1284->475 tok, ~$0.0024 saved) | critical 7/7 OK
+```
+
+---
+
+## Why this exists
+
+Every context compressor optimizes for one thing: fewer tokens. None of them tell
+you what they destroyed on the way.
+
+If your RAG app retrieves an invoice and the compressor drops or mangles
+`€47,350.00`, your LLM confidently answers with the wrong number and **you never
+find out**. That's fine for a chatbot. It is not fine for finance, legal,
+medical, compliance, or code.
+
+Quasar makes one guarantee no other compressor makes:
+
+> **It never silently corrupts your critical data.**
+> Critical values survive verbatim, or you get an explicit warning.
+
+---
+
+## What it does
+
+1. **Detects critical spans** — currency, IBANs, dates, VINs, long IDs, legal
+   references, contract codes — by pattern.
+2. **Reserves them verbatim.** Critical sentences claim budget first and are
+   never rewritten. (Token-deletion compressors *rewrite* text — that's how they
+   corrupt exact values.)
+3. **Fills the remaining budget by relevance**, using embedding similarity to the
+   query. Filler is dropped.
+4. **Dedupes** repeated sentences so budget isn't wasted on copies.
+5. **Audits and reports.** Every call returns tokens saved, cost saved, and a
+   faithfulness status — with warnings naming any critical value it couldn't fit.
+
+---
+
+## Honest benchmarks
+
+Measured on LongBench (narrativeqa / qasper / hotpotqa, N=30 per task), real LLM
+judge, token-F1 scoring.
+
+**Where Quasar wins:**
+
+| Matchup | Result |
+|---|---|
+| vs **truncation** | **9–0** — wins at every task and budget |
+| vs **LLMLingua** | **6–0** on accuracy, **8–13× faster** to compress |
+| Long contexts | Handles 17k+ word documents LLMLingua **cannot process at all** |
+
+LLMLingua runs a neural model to compress. Quasar runs embeddings. Same or better
+accuracy, a fraction of the compute.
+
+**Where Quasar does not win — stated plainly:**
+
+Against a **pure top-k embedding filter** (e.g. LangChain's `EmbeddingsFilter`),
+Quasar goes **3–6** on raw QA accuracy. On pure question-answering, simple
+relevance ranking is competitive or better.
+
+**So Quasar is not the accuracy leader on QA, and doesn't claim to be.** Its value
+is the axis those benchmarks don't measure: *faithfulness*. A top-k filter has no
+concept of critical data — it drops a low-relevance sentence containing your
+invoice number without hesitation, and never tells you. Quasar reserves it, and
+warns when it can't.
+
+**Use Quasar when correctness of exact values matters more than the last 2% of
+retrieval F1.** If you're building a general chatbot and only care about QA
+accuracy, use a top-k filter — it's simpler and we'll say so.
+
+---
+
+## Install
+
+```bash
+pip install quasar-context
+```
+
+## Usage
+
+### Basic
+
+```python
+from quasar import ContextOptimizer
+
+opt = ContextOptimizer()          # loads the embedding model once
+result = opt.optimize(
+    query="What is the total due and the deadline?",
+    context=retrieved_chunks,     # str or list[str]
+    target_tokens=500,
+)
+
+result.context                    # compressed text for your LLM
+result.report.tokens_saved        # int
+result.report.faithful            # bool — did all critical values survive?
+result.report.warnings            # list[str] — what got dropped and why
+```
+
+### Guarding a production call
+
+```python
+result = opt.optimize(query, chunks, target_tokens=500)
+
+if not result.report.faithful:
+    # budget too tight to hold every critical value — your call:
+    logger.warning("Quasar: %s", result.report.warnings)
+    result = opt.optimize(query, chunks, target_tokens=1000)   # give it room
+
+answer = llm(query, result.context)
+```
+
+### Configuration
+
+```python
+from quasar import ContextOptimizer, OptimizerConfig
+
+opt = ContextOptimizer(OptimizerConfig(
+    cost_per_1k_tokens=0.003,   # your model's price, for the savings report
+    preserve_critical=True,     # the faithfulness behavior (default on)
+    min_relevance=0.05,         # drop sentences below this query relevance
+    model_name="all-MiniLM-L6-v2",
+))
+```
+
+### Custom critical patterns
+
+Your domain has its own critical formats. Add them:
+
+```python
+from quasar import core
+core._CRITICAL_PATTERNS.append((r"\bCASE-\d{6}\b", "case_id"))
+```
+
+---
+
+## Performance
+
+- **~10–100 ms per call** after warm-up (embedding + greedy selection).
+- **First call loads the model** (~30–60s, one time). Warm it at startup:
+  ```python
+  opt = ContextOptimizer()
+  opt.optimize("warmup", "warmup text.", target_tokens=50)
+  ```
+- **8–13× faster than LLMLingua**, which runs a full neural model to compress.
+
+---
+
+## What Quasar is not
+
+- **Not the best compressor by ratio.** Token-deletion methods compress harder.
+  They also rewrite your text.
+- **Not an accuracy leader on pure QA.** A top-k filter matches or beats it there.
+- **Not a guarantee against physics.** If your critical content is larger than
+  your token budget, it cannot all fit. Quasar preserves what it can *and tells
+  you what it couldn't* — that's the honest contract.
+
+---
+
+## License
+
+MIT.

quasar_context-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quasar-context"
+version = "0.1.0"
+description = "Faithful context optimization for RAG apps — compress without corrupting critical data"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Sebastian Sabo" }]
+keywords = ["rag", "llm", "context", "compression", "prompt", "embeddings"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+dependencies = [
+    "sentence-transformers>=2.2.0",
+    "tiktoken>=0.5.0",
+    "numpy>=1.21.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov"]
+
+[project.urls]
+Homepage = "https://github.com/sebastiansabo/quasar"
+Issues = "https://github.com/sebastiansabo/quasar/issues"
+
+[tool.setuptools.packages.find]
+include = ["quasar*"]

quasar_context-0.1.0/quasar/__init__.py

@@ -0,0 +1,35 @@
+"""
+Quasar — faithful context optimization for RAG apps.
+
+Compress retrieved context before your LLM call. Critical values
+(prices, IBANs, dates, IDs, legal refs) are preserved verbatim when the
+budget allows — and you get an explicit warning when it can't, instead of
+silent corruption.
+
+Quick start:
+    from quasar import ContextOptimizer
+
+    opt = ContextOptimizer()
+    result = opt.optimize(query, retrieved_chunks, target_tokens=500)
+
+    result.context          # compressed context -> feed to your LLM
+    result.report.faithful  # bool: did every critical value survive?
+    print(result.report.summary())
+"""
+
+from .core import (
+    ContextOptimizer,
+    OptimizerConfig,
+    OptimizationResult,
+    OptimizationReport,
+    find_critical,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "ContextOptimizer",
+    "OptimizerConfig",
+    "OptimizationResult",
+    "OptimizationReport",
+    "find_critical",
+]

quasar_context-0.1.0/quasar/core.py

@@ -0,0 +1,296 @@
+"""
+================================================================================
+ quasar_layer.py  --  Drop-in context optimization for RAG apps
+================================================================================
+ WHAT IT IS
+ ----------
+ A single layer you insert between retrieval and your LLM call. It:
+   1. Picks the right compression strategy for the context automatically.
+   2. GUARANTEES exact critical content (IDs, prices, dates, citations) survives
+      verbatim -- the one thing pure relevance ranking can't promise.
+   3. Reports exactly what it did: tokens saved, est. cost saved, what was kept,
+      and any faithfulness risk it caught.
+
+ WHAT IS NOT
+ -----------
+ Not a magic compressor that beats everyone. Honest benchmarks showed
+ embedding-selection beats LLMLingua at far lower cost but ties/loses to simple
+ top-k on pure QA. So this layer's value is NOT "best compression" -- it is:
+   - zero-config: developer drops it in, no tuning
+   - safe-by-reporting: when budget can't fit all critical data, it does NOT
+     silently corrupt -- it preserves what fits and WARNS about what it dropped.
+     (No compressor can fit N critical facts into a budget smaller than them;
+     the honest behavior is to surface that, not hide it.)
+   - transparent: shows the savings + what the LLM actually sees
+   - cheap: embeddings, not an LLM-to-compress (8-13x faster than LLMLingua)
+
+ DESIGN PRINCIPLE
+ ----------------
+ The product is the DECISION + the PROOF, not the algorithm. Developers don't
+ know whether to compress, how much, or whether it's safe. This answers that
+ per-call, automatically, with receipts.
+
+ INSTALL
+   pip install sentence-transformers tiktoken
+
+ USE (the whole API is three lines)
+   from quasar_layer import ContextOptimizer
+   opt = ContextOptimizer()
+   result = opt.optimize(query, retrieved_chunks, target_tokens=500)
+   # result.context     -> compressed context, feed to your LLM
+   # result.report      -> tokens saved, cost saved, faithfulness status
+================================================================================
+"""
+from __future__ import annotations
+import re, time
+from dataclasses import dataclass, field
+from typing import Optional
+
+# ---------- optional deps, graceful fallback ----------
+try:
+    import tiktoken; _ENC = tiktoken.get_encoding("cl100k_base")
+except Exception:
+    _ENC = None
+def ntok(t: str) -> int:
+    if _ENC: return len(_ENC.encode(t))
+    return max(1, int(len(t.split()) * 1.3))
+
+_MODEL = None
+def _model(name="all-MiniLM-L6-v2"):
+    global _MODEL
+    if _MODEL is None:
+        from sentence_transformers import SentenceTransformer
+        _MODEL = SentenceTransformer(name)
+    return _MODEL
+
+
+# =============================================================================
+# CRITICAL CONTENT DETECTION  (the faithfulness guarantee)
+# =============================================================================
+# Spans matching these MUST survive verbatim. Extensible by the developer.
+_CRITICAL_PATTERNS = [
+    (r'[€$£¥]\s?\d[\d,.]*', "currency"),
+    (r'\b\d{1,3}(?:[,.]\d{3})+(?:\.\d+)?\b', "large_number"),
+    (r'\b[A-HJ-NPR-Z0-9]{17}\b', "vin"),
+    (r'\bRO\d{2}[A-Z0-9]{16,}\b', "iban"),
+    (r'\b[A-Z]{2}\d{2}[A-Z0-9]{10,}\b', "account"),
+    (r'\b\d{1,2}[/.\-]\d{1,2}[/.\-]\d{2,4}\b', "date"),
+    (r'\b(?:Order|Article|Regulation|Section|Clause|Directive)\s+[\w/.\-]+', "legal_ref"),
+    (r'\b[A-Z0-9]{6,}\-[A-Z0-9]{3,}\b', "code"),
+    (r'\b\d{6,}\b', "long_id"),
+]
+def find_critical(text: str) -> list[str]:
+    hits = []
+    for pat, kind in _CRITICAL_PATTERNS:
+        for m in re.finditer(pat, text):
+            hits.append(m.group(0))
+    return hits
+
+
+# =============================================================================
+# RESULT + REPORT
+# =============================================================================
+@dataclass
+class OptimizationReport:
+    tokens_in: int
+    tokens_out: int
+    tokens_saved: int
+    pct_saved: float
+    est_cost_saved_usd: float          # at a configurable $/1k tokens
+    strategy: str                      # which path was taken + why
+    critical_found: int
+    critical_preserved: int
+    faithful: bool                     # all critical content survived?
+    warnings: list = field(default_factory=list)
+    optimize_ms: float = 0.0
+    def summary(self) -> str:
+        flag = "OK" if self.faithful else "FAITHFULNESS RISK"
+        return (f"[Quasar] {self.pct_saved:.0f}% smaller "
+                f"({self.tokens_in}->{self.tokens_out} tok, "
+                f"~${self.est_cost_saved_usd:.4f} saved) | "
+                f"strategy={self.strategy} | critical {self.critical_preserved}/{self.critical_found} {flag}"
+                + ("" if not self.warnings else f" | {len(self.warnings)} warning(s)"))
+
+@dataclass
+class OptimizationResult:
+    context: str
+    report: OptimizationReport
+
+
+# =============================================================================
+# THE OPTIMIZER
+# =============================================================================
+@dataclass
+class OptimizerConfig:
+    cost_per_1k_tokens: float = 0.003   # for the savings estimate (set to your model)
+    skip_if_under: int = 0              # if context already <= target, don't touch it
+    min_relevance: float = 0.05         # drop sentences below this query relevance
+    preserve_critical: bool = True      # the faithfulness guarantee (on by default)
+    model_name: str = "all-MiniLM-L6-v2"
+
+class ContextOptimizer:
+    """
+    Drop-in: retrieved context in, optimized context out, with receipts.
+    Auto-selects strategy:
+      - context already within budget   -> passthrough (no cost, no risk)
+      - context over budget             -> faithful embedding-selection:
+          * reserve critical spans verbatim (guarantee)
+          * fill remaining budget by query relevance (the workhorse that
+            beat LLMLingua at a fraction of the cost)
+    """
+    def __init__(self, config: OptimizerConfig = OptimizerConfig()):
+        self.cfg = config
+
+    def _split(self, text: str) -> list[str]:
+        return [s.strip() for s in re.split(r'(?<=[.!?])\s+', text.strip()) if s.strip()]
+
+    def optimize(self, query: str, context, target_tokens: int = 500) -> OptimizationResult:
+        t0 = time.perf_counter()
+        # accept either a string or a list of chunks
+        if isinstance(context, (list, tuple)):
+            context = "\n".join(str(c) for c in context)
+        tokens_in = ntok(context)
+        crit_all = find_critical(context)
+
+        # ---- STEP 0: DEDUPE FIRST (always) ----
+        # Collapse identical sentences so we never spend budget on copies.
+        # This MUST run before the passthrough check: a context of 8 identical
+        # sentences may fit under the budget, but shipping 8 copies to the LLM
+        # wastes the very budget we exist to protect.
+        raw_sents = self._split(context)
+        seen = set(); sents = []
+        for s in raw_sents:
+            key = re.sub(r'\s+', ' ', s.strip().lower())
+            if key in seen: continue
+            seen.add(key); sents.append(s)
+        deduped = " ".join(sents)
+        tokens_deduped = ntok(deduped)
+        dupes_removed = len(raw_sents) - len(sents)
+
+        # ---- STRATEGY 1: passthrough if the DEDUPED context already fits ----
+        if tokens_deduped <= target_tokens:
+            saved = tokens_in - tokens_deduped
+            crit_kept = sum(1 for c in set(crit_all) if c in deduped)
+            strategy = ("passthrough (already within budget)" if dupes_removed == 0
+                        else f"dedupe-only ({dupes_removed} duplicate sentence(s) removed)")
+            rep = OptimizationReport(
+                tokens_in, tokens_deduped, saved,
+                100.0 * saved / max(1, tokens_in),
+                self.cfg.cost_per_1k_tokens * saved / 1000.0,
+                strategy=strategy,
+                critical_found=len(set(crit_all)),
+                critical_preserved=crit_kept,
+                faithful=(crit_kept == len(set(crit_all))),
+                optimize_ms=(time.perf_counter()-t0)*1000)
+            return OptimizationResult(deduped, rep)
+
+        # ---- STRATEGY 2: faithful embedding-selection ----
+        model = _model(self.cfg.model_name)
+        embs = model.encode([query] + sents, normalize_embeddings=True, show_progress_bar=False)
+        qv, svs = embs[0], embs[1:]
+        sims = svs @ qv
+        toks = [ntok(s) for s in sents]
+
+        chosen, used = [], 0
+        warnings = []
+
+        # 2a. reserve sentences containing critical spans (best-effort preservation)
+        if self.cfg.preserve_critical:
+            crit_idx = [i for i, s in enumerate(sents) if find_critical(s)]
+            # sort critical sentences by relevance so if budget is too tight we keep
+            # the most query-relevant critical ones first, and warn about drops
+            crit_idx.sort(key=lambda i: -sims[i])
+            for i in crit_idx:
+                if used + toks[i] <= target_tokens:
+                    chosen.append(i); used += toks[i]
+                else:
+                    warnings.append(f"critical sentence dropped (budget too tight): "
+                                    f"'{sents[i][:50]}...'")
+
+        # 2b. fill remaining budget with top relevance (skip already chosen + filler)
+        rest = [i for i in range(len(sents)) if i not in chosen]
+        rest.sort(key=lambda i: -sims[i])
+        for i in rest:
+            if float(sims[i]) < self.cfg.min_relevance: break
+            if used + toks[i] > target_tokens: continue
+            chosen.append(i); used += toks[i]
+
+        out_text = " ".join(sents[i] for i in sorted(chosen))
+        tokens_out = ntok(out_text)
+
+        # faithfulness audit: did every critical span survive verbatim?
+        crit_out = find_critical(out_text)
+        preserved = sum(1 for c in set(crit_all) if c in out_text)
+        faithful = (preserved == len(set(crit_all)))
+        if not faithful:
+            missing = [c for c in set(crit_all) if c not in out_text]
+            warnings.append(f"{len(missing)} critical value(s) not preserved: {missing[:3]}")
+
+        saved = tokens_in - tokens_out
+        rep = OptimizationReport(
+            tokens_in, tokens_out, saved,
+            100.0 * saved / max(1, tokens_in),
+            self.cfg.cost_per_1k_tokens * saved / 1000.0,
+            strategy="faithful-selection (critical reserved + relevance fill)",
+            critical_found=len(set(crit_all)),
+            critical_preserved=preserved,
+            faithful=faithful,
+            warnings=warnings,
+            optimize_ms=(time.perf_counter()-t0)*1000)
+        return OptimizationResult(out_text, rep)
+
+    # --- convenience: wrap an LLM call so the developer gets one-line integration ---
+    def optimized_prompt(self, query: str, context, target_tokens=500,
+                         template="Context:\n{context}\n\nQuestion: {query}\nAnswer:"):
+        res = self.optimize(query, context, target_tokens)
+        return template.format(context=res.context, query=query), res.report
+
+
+# =============================================================================
+# DEMO — shows the developer experience
+# =============================================================================
+def _demo():
+    sample_chunks = [
+        "The quarterly business review covered several operational topics across regions.",
+        "Market conditions have remained generally stable over the recent reporting period.",
+        "The invoice total amount due is €47,350.00 payable by 15/03/2026 per the agreement.",
+        "Various stakeholders provided feedback during the planning session last week.",
+        "The applicable regulation is Order 1802/2014 Article 7 governing this transaction.",
+        "Overall sector trends suggest continued steady commercial activity this year.",
+        "The vehicle identification number on record is WAUZZZ8K9BA123456 for this unit.",
+        "Documentation has been updated to reflect the latest procedural changes made.",
+        "The team continues to monitor performance metrics across all departments daily.",
+        "Payment should be remitted to IBAN RO49AAAA1B31007593840000 before the deadline.",
+    ] * 3   # triple it to force real compression
+
+    query = "What is the total amount due and the payment deadline?"
+
+    print("="*78)
+    print("QUASAR CONTEXT OPTIMIZER — developer experience demo")
+    print("="*78)
+    opt = ContextOptimizer(OptimizerConfig(cost_per_1k_tokens=0.003))
+
+    for budget in [120, 300]:
+        res = opt.optimize(query, sample_chunks, target_tokens=budget)
+        print(f"\n--- target_tokens={budget} ---")
+        print(res.report.summary())
+        print(f"  optimize time: {res.report.optimize_ms:.0f} ms")
+        if res.report.warnings:
+            for w in res.report.warnings: print(f"  ! {w}")
+        print(f"  LLM now sees ({res.report.tokens_out} tok):")
+        print(f'    "{res.context[:220]}..."')
+
+    print("\n" + "="*78)
+    print("THE PITCH (honest):")
+    print("  - 3-line drop-in: optimize(query, chunks, target_tokens)")
+    print("  - Auto-passthrough when context already fits (no needless cost/risk)")
+    print("  - Preserves critical values (prices, IBANs, dates, refs) verbatim when")
+    print("    budget allows -- and WARNS (never silently corrupts) when it can't")
+    print("  - Dedupes repeated content so budget isn't wasted on copies")
+    print("  - 8-13x cheaper to run than LLMLingua (embeddings, not an LLM)")
+    print("  - Every call returns receipts: tokens saved, $ saved, faithfulness status")
+    print("  - The product is the DECISION + PROOF, not a 'magic' compressor.")
+    print("="*78)
+
+if __name__ == "__main__":
+    _demo()

quasar_context-0.1.0/quasar_context.egg-info/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: quasar-context
+Version: 0.1.0
+Summary: Faithful context optimization for RAG apps — compress without corrupting critical data
+Author: Sebastian Sabo
+License: MIT
+Project-URL: Homepage, https://github.com/sebastiansabo/quasar
+Project-URL: Issues, https://github.com/sebastiansabo/quasar/issues
+Keywords: rag,llm,context,compression,prompt,embeddings
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: tiktoken>=0.5.0
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# Quasar
+
+**Faithful context optimization for RAG apps.**
+
+Compress retrieved context before your LLM call — without silently corrupting the
+values that matter. Prices, IBANs, dates, invoice numbers, legal references and
+IDs are preserved **verbatim** when the budget allows. When it doesn't, Quasar
+**tells you** instead of quietly dropping them.
+
+```python
+from quasar import ContextOptimizer
+
+opt = ContextOptimizer()
+result = opt.optimize(query, retrieved_chunks, target_tokens=500)
+
+llm_answer(query, result.context)      # feed the compressed context
+print(result.report.summary())
+# [Quasar] 63% smaller (1284->475 tok, ~$0.0024 saved) | critical 7/7 OK
+```
+
+---
+
+## Why this exists
+
+Every context compressor optimizes for one thing: fewer tokens. None of them tell
+you what they destroyed on the way.
+
+If your RAG app retrieves an invoice and the compressor drops or mangles
+`€47,350.00`, your LLM confidently answers with the wrong number and **you never
+find out**. That's fine for a chatbot. It is not fine for finance, legal,
+medical, compliance, or code.
+
+Quasar makes one guarantee no other compressor makes:
+
+> **It never silently corrupts your critical data.**
+> Critical values survive verbatim, or you get an explicit warning.
+
+---
+
+## What it does
+
+1. **Detects critical spans** — currency, IBANs, dates, VINs, long IDs, legal
+   references, contract codes — by pattern.
+2. **Reserves them verbatim.** Critical sentences claim budget first and are
+   never rewritten. (Token-deletion compressors *rewrite* text — that's how they
+   corrupt exact values.)
+3. **Fills the remaining budget by relevance**, using embedding similarity to the
+   query. Filler is dropped.
+4. **Dedupes** repeated sentences so budget isn't wasted on copies.
+5. **Audits and reports.** Every call returns tokens saved, cost saved, and a
+   faithfulness status — with warnings naming any critical value it couldn't fit.
+
+---
+
+## Honest benchmarks
+
+Measured on LongBench (narrativeqa / qasper / hotpotqa, N=30 per task), real LLM
+judge, token-F1 scoring.
+
+**Where Quasar wins:**
+
+| Matchup | Result |
+|---|---|
+| vs **truncation** | **9–0** — wins at every task and budget |
+| vs **LLMLingua** | **6–0** on accuracy, **8–13× faster** to compress |
+| Long contexts | Handles 17k+ word documents LLMLingua **cannot process at all** |
+
+LLMLingua runs a neural model to compress. Quasar runs embeddings. Same or better
+accuracy, a fraction of the compute.
+
+**Where Quasar does not win — stated plainly:**
+
+Against a **pure top-k embedding filter** (e.g. LangChain's `EmbeddingsFilter`),
+Quasar goes **3–6** on raw QA accuracy. On pure question-answering, simple
+relevance ranking is competitive or better.
+
+**So Quasar is not the accuracy leader on QA, and doesn't claim to be.** Its value
+is the axis those benchmarks don't measure: *faithfulness*. A top-k filter has no
+concept of critical data — it drops a low-relevance sentence containing your
+invoice number without hesitation, and never tells you. Quasar reserves it, and
+warns when it can't.
+
+**Use Quasar when correctness of exact values matters more than the last 2% of
+retrieval F1.** If you're building a general chatbot and only care about QA
+accuracy, use a top-k filter — it's simpler and we'll say so.
+
+---
+
+## Install
+
+```bash
+pip install quasar-context
+```
+
+## Usage
+
+### Basic
+
+```python
+from quasar import ContextOptimizer
+
+opt = ContextOptimizer()          # loads the embedding model once
+result = opt.optimize(
+    query="What is the total due and the deadline?",
+    context=retrieved_chunks,     # str or list[str]
+    target_tokens=500,
+)
+
+result.context                    # compressed text for your LLM
+result.report.tokens_saved        # int
+result.report.faithful            # bool — did all critical values survive?
+result.report.warnings            # list[str] — what got dropped and why
+```
+
+### Guarding a production call
+
+```python
+result = opt.optimize(query, chunks, target_tokens=500)
+
+if not result.report.faithful:
+    # budget too tight to hold every critical value — your call:
+    logger.warning("Quasar: %s", result.report.warnings)
+    result = opt.optimize(query, chunks, target_tokens=1000)   # give it room
+
+answer = llm(query, result.context)
+```
+
+### Configuration
+
+```python
+from quasar import ContextOptimizer, OptimizerConfig
+
+opt = ContextOptimizer(OptimizerConfig(
+    cost_per_1k_tokens=0.003,   # your model's price, for the savings report
+    preserve_critical=True,     # the faithfulness behavior (default on)
+    min_relevance=0.05,         # drop sentences below this query relevance
+    model_name="all-MiniLM-L6-v2",
+))
+```
+
+### Custom critical patterns
+
+Your domain has its own critical formats. Add them:
+
+```python
+from quasar import core
+core._CRITICAL_PATTERNS.append((r"\bCASE-\d{6}\b", "case_id"))
+```
+
+---
+
+## Performance
+
+- **~10–100 ms per call** after warm-up (embedding + greedy selection).
+- **First call loads the model** (~30–60s, one time). Warm it at startup:
+  ```python
+  opt = ContextOptimizer()
+  opt.optimize("warmup", "warmup text.", target_tokens=50)
+  ```
+- **8–13× faster than LLMLingua**, which runs a full neural model to compress.
+
+---
+
+## What Quasar is not
+
+- **Not the best compressor by ratio.** Token-deletion methods compress harder.
+  They also rewrite your text.
+- **Not an accuracy leader on pure QA.** A top-k filter matches or beats it there.
+- **Not a guarantee against physics.** If your critical content is larger than
+  your token budget, it cannot all fit. Quasar preserves what it can *and tells
+  you what it couldn't* — that's the honest contract.
+
+---
+
+## License
+
+MIT.

quasar_context-0.1.0/quasar_context.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+quasar/__init__.py
+quasar/core.py
+quasar_context.egg-info/PKG-INFO
+quasar_context.egg-info/SOURCES.txt
+quasar_context.egg-info/dependency_links.txt
+quasar_context.egg-info/requires.txt
+quasar_context.egg-info/top_level.txt
+tests/test_core.py

quasar_context-0.1.0/quasar_context.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quasar_context-0.1.0/quasar_context.egg-info/requires.txt

@@ -0,0 +1,7 @@
+sentence-transformers>=2.2.0
+tiktoken>=0.5.0
+numpy>=1.21.0
+
+[dev]
+pytest>=7.0
+pytest-cov

quasar_context-0.1.0/quasar_context.egg-info/top_level.txt

@@ -0,0 +1 @@
+quasar

quasar_context-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

quasar_context-0.1.0/tests/test_core.py

@@ -0,0 +1,108 @@
+"""
+Tests for Quasar. The critical ones assert the FAITHFULNESS CONTRACT:
+  - critical values survive verbatim when budget allows
+  - when budget is too tight, the report says so (never silent)
+If these fail, the product's only differentiator is broken.
+"""
+import pytest
+from quasar import ContextOptimizer, OptimizerConfig, find_critical
+
+
+# ---------------------------------------------------------------- fixtures
+@pytest.fixture(scope="module")
+def opt():
+    return ContextOptimizer(OptimizerConfig(cost_per_1k_tokens=0.003))
+
+
+CRITICAL_CHUNKS = [
+    "The quarterly business review covered several operational topics.",
+    "The invoice total amount due is €47,350.00 payable by 15/03/2026.",
+    "Market conditions have remained generally stable this period.",
+    "Payment should be remitted to IBAN RO49AAAA1B31007593840000 promptly.",
+    "The team continues to monitor performance metrics across departments.",
+    "The applicable regulation is Order 1802/2014 governing this deal.",
+    "Documentation has been updated to reflect procedural changes made.",
+]
+QUERY = "What is the total amount due and the payment deadline?"
+
+
+# ---------------------------------------------------------------- detection
+def test_finds_currency():
+    assert any("47,350" in c for c in find_critical("Total is €47,350.00 due now."))
+
+def test_finds_iban():
+    hits = find_critical("Send to RO49AAAA1B31007593840000 today.")
+    assert any("RO49AAAA" in h for h in hits)
+
+def test_finds_date():
+    assert find_critical("Due by 15/03/2026 without fail.")
+
+def test_ignores_plain_prose():
+    assert find_critical("The weather today is mild and pleasant.") == []
+
+
+# ---------------------------------------------------------------- the contract
+def test_critical_preserved_when_budget_allows(opt):
+    """THE core claim: with room, every critical value survives verbatim."""
+    res = opt.optimize(QUERY, CRITICAL_CHUNKS, target_tokens=300)
+    assert res.report.faithful, f"critical data lost: {res.report.warnings}"
+    assert "€47,350.00" in res.context
+    assert "RO49AAAA1B31007593840000" in res.context
+    assert "15/03/2026" in res.context
+    assert res.report.critical_preserved == res.report.critical_found
+
+def test_warns_when_budget_too_tight(opt):
+    """THE honesty claim: if it can't fit critical data, it MUST say so."""
+    res = opt.optimize(QUERY, CRITICAL_CHUNKS, target_tokens=15)
+    if not res.report.faithful:
+        assert res.report.warnings, "dropped critical data but issued NO warning"
+        assert res.report.critical_preserved < res.report.critical_found
+
+def test_never_silently_drops(opt):
+    """faithful==False must always be accompanied by warnings."""
+    for budget in (10, 20, 30, 50, 80, 200, 400):
+        res = opt.optimize(QUERY, CRITICAL_CHUNKS, target_tokens=budget)
+        if not res.report.faithful:
+            assert res.report.warnings, f"silent drop at budget={budget}"
+
+
+# ---------------------------------------------------------------- behavior
+def test_passthrough_when_already_small(opt):
+    res = opt.optimize(QUERY, "Short context.", target_tokens=500)
+    assert "passthrough" in res.report.strategy
+    assert res.report.tokens_saved == 0
+    assert res.report.faithful
+
+def test_actually_compresses(opt):
+    big = CRITICAL_CHUNKS * 6
+    res = opt.optimize(QUERY, big, target_tokens=200)
+    assert res.report.tokens_out <= 200
+    assert res.report.tokens_saved > 0
+    assert res.report.pct_saved > 0
+
+def test_dedupes_repeats(opt):
+    """Duplicate sentences must not each consume budget."""
+    dupes = ["The invoice total amount due is €47,350.00 payable soon."] * 8
+    res = opt.optimize(QUERY, dupes, target_tokens=100)
+    assert res.context.count("€47,350.00") == 1, "kept duplicate critical sentences"
+
+def test_accepts_string_or_list(opt):
+    as_list = opt.optimize(QUERY, CRITICAL_CHUNKS, target_tokens=200)
+    as_str = opt.optimize(QUERY, " ".join(CRITICAL_CHUNKS), target_tokens=200)
+    assert as_list.report.tokens_out == as_str.report.tokens_out
+
+
+# ---------------------------------------------------------------- report
+def test_report_is_complete(opt):
+    res = opt.optimize(QUERY, CRITICAL_CHUNKS * 4, target_tokens=150)
+    r = res.report
+    assert r.tokens_in > r.tokens_out
+    assert r.tokens_saved == r.tokens_in - r.tokens_out
+    assert 0 <= r.pct_saved <= 100
+    assert r.est_cost_saved_usd >= 0
+    assert isinstance(r.faithful, bool)
+    assert r.summary()
+
+def test_empty_context_does_not_crash(opt):
+    res = opt.optimize(QUERY, "", target_tokens=100)
+    assert res.context == "" or res.report.faithful