chopper-rag 0.1.0__py3-none-any.whl

chopper_rag/__init__.py

@@ -0,0 +1,11 @@
+"""chopper-rag: the chopper context compressor (exact quotes cut out of retrieved snippets) for RAG pipelines.
+
+Framework adapters live in submodules so that importing this package needs none of the frameworks:
+    chopper_rag.langchain.ChopperCompressor             (langchain-core)
+    chopper_rag.llama_index.ChopperPostprocessor        (llama-index-core)
+    chopper_rag.haystack.ChopperDocumentCompressor      (haystack-ai)
+"""
+from .core import Chop, ChopResult, Chopper
+
+__all__ = ["Chop", "ChopResult", "Chopper"]
+__version__ = "0.1.0"

chopper_rag/core.py

@@ -0,0 +1,221 @@
+"""The chopper: a fine-tuned mmBERT encoder that cuts exact quotes ("chops") out of retrieved passages.
+
+Input to the model, one string of at most 8,192 tokens:
+
+    "Question: <question> [SEP] <passage 1> [SEP] ... [SEP] <passage N>"
+
+Per token the KEEP head gives p(KEEP); the decision head on the first token gives SEARCH (0) / ANSWER (1).
+Decoding (the one the published results were measured with): keep passage tokens with p > pred_thr, merge kept runs
+separated by <= merge_gap tokens, drop runs shorter than min_run tokens, bridge the single character between two kept
+tokens, then map each run back to character offsets of the ORIGINAL passage strings.
+
+Passages that do not fit into one 8,192-token input are processed in several forward passes: passages are packed
+greedily, in order, into groups that fit next to the question; a single passage longer than the whole budget is cut
+into windows at token boundaries. Each group is chopped exactly like a single input; chop offsets always refer to the
+original passage. The model was trained on inputs of up to ~20 passages of ~1,000 characters, so splitting changes
+nothing for typical retriever outputs (16-20 passages fit in one pass).
+"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+
+import numpy as np
+import torch
+
+DEFAULT_REPO = "wiiiktor/chopper_mmbert"
+VARIANTS = {"base": "mmbert-base", "small": "mmbert-small"}
+MAX_LEN = 8192
+_SAFETY = 32          # tokens kept free when packing groups (tokenisation at segment borders may differ slightly)
+
+
+@dataclass
+class Chop:
+    """One exact quote: ``passages[passage_index][start:end] == text``."""
+    passage_index: int
+    start: int
+    end: int
+    text: str
+    score: float | None = None        # mean p(KEEP) over the run's tokens
+
+
+@dataclass
+class ChopResult:
+    chops: list[Chop]
+    decision: str                     # "ANSWER" (the passages hold the answer) or "SEARCH" (search again)
+    p_answer: float                   # p(ANSWER); with several forward passes, the maximum over them
+    n_passes: int = 1                 # forward passes used (> 1 when the input did not fit 8,192 tokens)
+    texts: list[str] = field(default_factory=list)   # chop texts, in order
+
+    def __iter__(self):
+        return iter(self.chops)
+
+    def __len__(self):
+        return len(self.chops)
+
+
+# ------------------------------------------------------------------ decoding (identical to the reference operator)
+def _runs(m):
+    d = np.diff(np.concatenate([[0], m.astype(np.int8), [0]]))
+    return list(zip(np.where(d == 1)[0], np.where(d == -1)[0]))
+
+
+def shape(q, gap=5, mn=4):
+    """merge kept runs <= gap tokens apart, drop runs shorter than mn"""
+    q = q.copy()
+    rr = _runs(q)
+    for (a0, b0), (a1, b1) in zip(rr, rr[1:]):
+        if a1 - b0 <= gap:
+            q[b0:a1] = True
+    for a0, b0 in _runs(q):
+        if b0 - a0 < mn:
+            q[a0:b0] = False
+    return q
+
+
+def kept_text(s, offsets, q):
+    """kept tokens -> contiguous character runs of the string s"""
+    cm = np.zeros(len(s) + 1, dtype=bool)
+    for (a, b), k in zip(offsets, q):
+        if k:
+            cm[a:b] = True
+    cm[1:-1] |= cm[:-2] & cm[2:]                     # bridge the space between two kept tokens
+    return [(int(a), int(b)) for a, b in _runs(cm)]
+
+
+def _fetch(repo, folder):
+    """a local copy (repo is a directory holding mmbert-base/ ...) or a Hugging Face download"""
+    if os.path.isdir(os.path.join(repo, folder)):
+        return os.path.join(repo, folder)
+    from huggingface_hub import snapshot_download
+    return os.path.join(snapshot_download(repo, allow_patterns=[f"{folder}/*"]), folder)
+
+
+class Chopper:
+    """Load with :meth:`from_pretrained`; call :meth:`chop` (list of :class:`Chop`) or :meth:`run` (+ decision)."""
+
+    def __init__(self, tokenizer, encoder, heads, device, threshold=0.5, merge_gap=5, min_run=4, max_length=MAX_LEN):
+        self.tokenizer, self.encoder, self.device = tokenizer, encoder, device
+        self.heads = {k: v.to(device).float() for k, v in heads.items()}
+        self.threshold, self.merge_gap, self.min_run, self.max_length = threshold, merge_gap, min_run, max_length
+        self.sep = f" {tokenizer.sep_token} "
+
+    @classmethod
+    def from_pretrained(cls, repo: str = DEFAULT_REPO, variant: str = "base", device: str = "auto",
+                        threshold: float | None = None, dtype: torch.dtype | None = None) -> "Chopper":
+        """repo: HF repo id or a local directory containing ``mmbert-base/`` / ``mmbert-small/``.
+        variant: "base" (0.31B, recommended) or "small" (0.14B). threshold: p(KEEP) cut-off (default from
+        chopper_config.json). dtype: default bfloat16 on CUDA, float32 on CPU."""
+        from safetensors.torch import load_file
+        from transformers import AutoModel, AutoTokenizer
+        if variant not in VARIANTS:
+            raise ValueError(f"variant must be one of {list(VARIANTS)}, got {variant!r}")
+        if device == "auto":
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        if dtype is None:
+            dtype = torch.bfloat16 if str(device).startswith("cuda") else torch.float32
+        d = _fetch(repo, VARIANTS[variant])
+        tok = AutoTokenizer.from_pretrained(f"{d}/encoder")
+        enc = AutoModel.from_pretrained(f"{d}/encoder", dtype=dtype).to(device).eval()
+        heads = load_file(f"{d}/heads.safetensors")
+        dec = json.load(open(f"{d}/chopper_config.json")).get("decode", {})
+        thr = dec.get("pred_thr", 0.5) if threshold is None else threshold
+        return cls(tok, enc, heads, device, threshold=thr, merge_gap=dec.get("merge_gap", 5),
+                   min_run=dec.get("min_run", 4))
+
+    # -------------------------------------------------------------- public API
+    def chop(self, question: str, passages: list[str]) -> list[Chop]:
+        """the chops (exact quotes) of ``passages`` for ``question``, in passage order"""
+        return self.run(question, passages).chops
+
+    def run(self, question: str, passages: list[str]) -> ChopResult:
+        """chops plus the ANSWER / SEARCH decision"""
+        passages = [p if isinstance(p, str) else str(p) for p in passages]
+        head = f"Question: {question}"
+        segs = self._segments(head, passages)
+        chops, p_ans, n = [], 0.0, 0
+        for group in self._groups(head, segs):
+            c, pa = self._forward(head, group, passages)
+            chops += c; p_ans = max(p_ans, pa); n += 1
+        if n == 0:                                                     # no passages: nothing to keep, search
+            p_ans = self._forward(head, [], passages)[1]; n = 1
+        chops.sort(key=lambda c: (c.passage_index, c.start))
+        return ChopResult(chops, "ANSWER" if p_ans >= 0.5 else "SEARCH", p_ans, n, [c.text for c in chops])
+
+    __call__ = run
+
+    # -------------------------------------------------------------- internals
+    def _ntok(self, text):
+        return len(self.tokenizer(text, add_special_tokens=False)["input_ids"])
+
+    def _segments(self, head, passages):
+        """(passage_index, char offset in the passage, text): stripped passages, too-long ones cut into windows"""
+        budget = self.max_length - self._ntok(head) - 2 - _SAFETY       # [CLS]/[SEP] + one separator
+        if budget < 16:
+            raise ValueError("the question alone fills the 8,192-token input")
+        segs = []
+        for i, p in enumerate(passages):
+            s = p.strip()
+            if not s:
+                continue
+            lead = len(p) - len(p.lstrip())
+            e = self.tokenizer(s, add_special_tokens=False, return_offsets_mapping=True)
+            off = e["offset_mapping"]
+            if len(off) <= budget:
+                segs.append((i, lead, s, len(off)))
+                continue
+            for w in range(0, len(off), budget):                       # one very long passage: token windows
+                a, b = off[w][0], off[min(w + budget, len(off)) - 1][1]
+                t = s[a:b]
+                tl = len(t) - len(t.lstrip())
+                if t.strip():
+                    segs.append((i, lead + a + tl, t.strip(), min(budget, len(off) - w)))
+        return segs
+
+    def _groups(self, head, segs):
+        """greedy, in order: as many segments per forward pass as fit into max_length"""
+        limit = self.max_length - self._ntok(head) - 2 - _SAFETY
+        group, used = [], 0
+        for sg in segs:
+            cost = sg[3] + 2                                           # the passage + its " [SEP] "
+            if group and used + cost > limit:
+                yield group; group, used = [], 0
+            group.append(sg); used += cost
+        if group:
+            yield group
+
+    @torch.no_grad()
+    def _forward(self, head, group, passages):
+        s, spans = head, []
+        for (i, off, text, _) in group:
+            s += self.sep
+            spans.append((len(s), len(s) + len(text), i, off))
+            s += text
+        e = self.tokenizer(s, return_offsets_mapping=True, truncation=True, max_length=self.max_length,
+                           return_tensors="pt")
+        if len(group) > 1 and e["input_ids"].shape[1] >= self.max_length:  # estimate was off: split the group
+            m = len(group) // 2
+            c1, p1 = self._forward(head, group[:m], passages)
+            c2, p2 = self._forward(head, group[m:], passages)
+            return c1 + c2, max(p1, p2)
+        off = e.pop("offset_mapping")[0].tolist()
+        h = self.encoder(**{k: v.to(self.device) for k, v in e.items()}).last_hidden_state[0].float()
+        p = torch.sigmoid(h @ self.heads["keep.weight"].T + self.heads["keep.bias"])[:, 0].cpu().numpy()
+        p_ans = float(torch.softmax(h[0] @ self.heads["decision.weight"].T + self.heads["decision.bias"], -1)[1])
+        body = np.array([a >= len(head) and b > a for a, b in off])
+        q = shape((p > self.threshold) & body, self.merge_gap, self.min_run) & body
+        out = []
+        for a, b in kept_text(s, off, q):
+            for (sa, sb, i, poff) in spans:                            # a run may cross a separator: cut per passage
+                x, y = max(a, sa), min(b, sb)
+                if y <= x:
+                    continue
+                t = s[x:y]
+                x += len(t) - len(t.lstrip()); y -= len(t) - len(t.rstrip())
+                if y - x <= 2:
+                    continue
+                ts = [k for k, (u, v) in enumerate(off) if q[k] and u < y and v > x]
+                start, end = poff + (x - sa), poff + (y - sa)
+                out.append(Chop(i, start, end, passages[i][start:end], float(p[ts].mean()) if ts else None))
+        return out, p_ans

chopper_rag/haystack.py

@@ -0,0 +1,47 @@
+"""Haystack 2.x / 3.x: ``ChopperDocumentCompressor`` component, placed after a retriever or ranker."""
+from __future__ import annotations
+
+from typing import Any
+
+from haystack import Document, component, default_from_dict, default_to_dict
+
+from .core import DEFAULT_REPO, Chopper
+
+
+@component
+class ChopperDocumentCompressor:
+    """Replaces the documents by one Document per chop (the exact quote). ``meta`` = the source document's meta +
+    ``chop_start``/``chop_end`` (character offsets in the source ``content``), ``source_index``, ``source_id`` and
+    ``chop_score``; ``score`` = the source document's score. Outputs ``documents`` and ``decision``
+    ("ANSWER" or "SEARCH": whether the documents hold the answer)."""
+
+    def __init__(self, repo: str = DEFAULT_REPO, variant: str = "base", device: str = "auto",
+                 threshold: float | None = None) -> None:
+        self.repo, self.variant, self.device, self.threshold = repo, variant, device, threshold
+        self._chopper: Chopper | None = None
+
+    def warm_up(self) -> None:
+        if self._chopper is None:
+            self._chopper = Chopper.from_pretrained(self.repo, variant=self.variant, device=self.device,
+                                                    threshold=self.threshold)
+
+    def to_dict(self) -> dict[str, Any]:
+        return default_to_dict(self, repo=self.repo, variant=self.variant, device=self.device,
+                               threshold=self.threshold)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ChopperDocumentCompressor":
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=list[Document], decision=str)
+    def run(self, documents: list[Document], query: str) -> dict[str, Any]:
+        self.warm_up()
+        if not documents:
+            return {"documents": [], "decision": "SEARCH"}
+        res = self._chopper.run(query, [d.content or "" for d in documents])
+        out = [Document(content=c.text, score=documents[c.passage_index].score,
+                        meta={**documents[c.passage_index].meta, "chop_start": c.start, "chop_end": c.end,
+                              "source_index": c.passage_index, "source_id": documents[c.passage_index].id,
+                              "chop_score": c.score})
+               for c in res.chops]
+        return {"documents": out, "decision": res.decision}

chopper_rag/langchain.py

@@ -0,0 +1,44 @@
+"""LangChain: ``ChopperCompressor`` (a ``BaseDocumentCompressor``), e.g. inside a ``ContextualCompressionRetriever``."""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from langchain_core.callbacks import Callbacks
+from langchain_core.documents import BaseDocumentCompressor, Document
+from pydantic import ConfigDict
+
+from .core import DEFAULT_REPO, Chopper
+
+
+class ChopperCompressor(BaseDocumentCompressor):
+    """Returns one Document per chop: ``page_content`` = the exact quote, ``metadata`` = the source document's
+    metadata + ``chop_start``/``chop_end`` (character offsets in the source ``page_content``), ``source_index``
+    (position of the source in the input list) and ``chop_score`` (mean p(KEEP)).
+    The ANSWER / SEARCH decision of the last call is in ``last_decision``."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    chopper: Any = None
+    last_decision: str | None = None
+
+    @classmethod
+    def from_pretrained(cls, repo: str = DEFAULT_REPO, variant: str = "base", device: str = "auto",
+                        threshold: float | None = None) -> "ChopperCompressor":
+        return cls(chopper=Chopper.from_pretrained(repo, variant=variant, device=device, threshold=threshold))
+
+    def model_post_init(self, __context: Any) -> None:
+        if self.chopper is None:
+            self.chopper = Chopper.from_pretrained()
+
+    def compress_documents(self, documents: Sequence[Document], query: str,
+                           callbacks: Callbacks | None = None) -> Sequence[Document]:
+        documents = list(documents)
+        if not documents:
+            return []
+        res = self.chopper.run(query, [d.page_content for d in documents])
+        self.last_decision = res.decision
+        return [Document(page_content=c.text,
+                         metadata={**documents[c.passage_index].metadata, "chop_start": c.start, "chop_end": c.end,
+                                   "source_index": c.passage_index, "chop_score": c.score})
+                for c in res.chops]

chopper_rag/llama_index.py

@@ -0,0 +1,57 @@
+"""LlamaIndex: ``ChopperPostprocessor`` (a ``BaseNodePostprocessor``), e.g. ``node_postprocessors=[...]`` of a
+query engine."""
+from __future__ import annotations
+
+from typing import Any, List, Optional
+
+from llama_index.core.bridge.pydantic import Field, PrivateAttr
+from llama_index.core.postprocessor.types import BaseNodePostprocessor
+from llama_index.core.schema import MetadataMode, NodeRelationship, NodeWithScore, QueryBundle, TextNode
+
+from .core import DEFAULT_REPO, Chopper
+
+
+class ChopperPostprocessor(BaseNodePostprocessor):
+    """Replaces the retrieved nodes by one TextNode per chop (the exact quote). Metadata = the source node's
+    metadata + ``chop_start``/``chop_end`` (character offsets in the source node's text), ``source_index`` and
+    ``chop_score``; the SOURCE relationship points to the source node; the score is the source node's score.
+    The ANSWER / SEARCH decision of the last call is in ``last_decision``."""
+
+    repo: str = Field(default=DEFAULT_REPO, description="HF repo id or local directory of the chopper weights")
+    variant: str = Field(default="base", description="'base' (0.31B, recommended) or 'small' (0.14B)")
+    device: str = Field(default="auto")
+    threshold: Optional[float] = Field(default=None, description="p(KEEP) cut-off; default from the model config")
+    last_decision: Optional[str] = None
+    _chopper: Any = PrivateAttr(default=None)
+
+    def __init__(self, chopper: Optional[Chopper] = None, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._chopper = chopper or Chopper.from_pretrained(self.repo, variant=self.variant, device=self.device,
+                                                           threshold=self.threshold)
+
+    @classmethod
+    def class_name(cls) -> str:
+        return "ChopperPostprocessor"
+
+    def _postprocess_nodes(self, nodes: List[NodeWithScore],
+                           query_bundle: Optional[QueryBundle] = None) -> List[NodeWithScore]:
+        if query_bundle is None:
+            raise ValueError("ChopperPostprocessor needs the query (query_bundle or query_str)")
+        if not nodes:
+            return []
+        texts = [n.node.get_content(metadata_mode=MetadataMode.NONE) for n in nodes]
+        res = self._chopper.run(query_bundle.query_str, texts)
+        self.last_decision = res.decision
+        out = []
+        for c in res.chops:
+            src = nodes[c.passage_index]
+            node = TextNode(
+                text=c.text,
+                metadata={**src.node.metadata, "chop_start": c.start, "chop_end": c.end,
+                          "source_index": c.passage_index, "chop_score": c.score},
+                excluded_embed_metadata_keys=list(src.node.excluded_embed_metadata_keys),
+                excluded_llm_metadata_keys=list(src.node.excluded_llm_metadata_keys),
+                relationships={NodeRelationship.SOURCE: src.node.as_related_node_info()},
+            )
+            out.append(NodeWithScore(node=node, score=src.score))
+        return out

chopper_rag-0.1.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: chopper-rag
+Version: 0.1.0
+Summary: The chopper context compressor for RAG: exact quotes cut out of retrieved snippets, for LangChain, LlamaIndex and Haystack
+Author: wiiiktor
+License-Expression: MIT
+Project-URL: Model, https://huggingface.co/wiiiktor/chopper_mmbert
+Project-URL: Source, https://github.com/wiiiktor/chopper_demo
+Keywords: rag,context-compression,langchain,llama-index,haystack,mmbert
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1
+Requires-Dist: transformers>=4.48
+Requires-Dist: safetensors
+Requires-Dist: huggingface_hub
+Requires-Dist: numpy
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == "langchain"
+Provides-Extra: llama-index
+Requires-Dist: llama-index-core>=0.12; extra == "llama-index"
+Provides-Extra: haystack
+Requires-Dist: haystack-ai>=2.0; extra == "haystack"
+Provides-Extra: all
+Requires-Dist: langchain-core>=0.3; extra == "all"
+Requires-Dist: llama-index-core>=0.12; extra == "all"
+Requires-Dist: haystack-ai>=2.0; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# chopper-rag
+
+The **chopper** as a drop-in context compressor for LangChain, LlamaIndex and Haystack.
+
+The chopper is a fine-tuned mmBERT encoder. It reads the question and the snippets your retriever returned, and cuts out
+**chops**: exact quotes cut out of retrieved snippets, never rewritten. A chop is typically 3-5% of the retrieved
+text. Every chop records where it came from (`passage[start:end] == text`), and the chops work with any answering model.
+It also gives one **ANSWER / SEARCH** decision: whether the snippets seem to contain the answer, or you should search again.
+
+- Model: [huggingface.co/wiiiktor/chopper_mmbert](https://huggingface.co/wiiiktor/chopper_mmbert): `base` (0.31B, recommended) and `small` (0.14B)
+- Code and demo: [github.com/wiiiktor/chopper_demo](https://github.com/wiiiktor/chopper_demo)
+
+## Install
+
+```bash
+pip install chopper-rag                  # core only (torch, transformers)
+pip install "chopper-rag[langchain]"     # or [llama-index], [haystack], [all]
+```
+
+## Core
+
+```python
+from chopper_rag import Chopper
+
+chopper = Chopper.from_pretrained(variant="base")          # device="auto", threshold from the model config
+result = chopper.run("When was the Eiffel Tower completed?", passages)
+for c in result.chops:                                      # Chop(passage_index, start, end, text, score)
+    assert passages[c.passage_index][c.start:c.end] == c.text
+print(result.decision)                                      # "ANSWER" or "SEARCH"
+chops = chopper.chop(question, passages)                    # just the list of Chop
+```
+
+## LangChain
+
+```python
+from langchain_classic.retrievers import ContextualCompressionRetriever  # langchain<1.0: langchain.retrievers
+from chopper_rag.langchain import ChopperCompressor
+
+compressor = ChopperCompressor.from_pretrained(variant="base")
+retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=vectorstore.as_retriever(search_kwargs={"k": 16}))
+docs = retriever.invoke("When was the Eiffel Tower completed?")
+for d in docs:   # one Document per chop
+    print(d.page_content, d.metadata["source_index"], d.metadata["chop_start"], d.metadata["chop_end"])
+# or directly: compressor.compress_documents(documents, query)
+```
+
+## LlamaIndex
+
+```python
+from chopper_rag.llama_index import ChopperPostprocessor
+
+chopper = ChopperPostprocessor(variant="base")
+query_engine = index.as_query_engine(similarity_top_k=16, node_postprocessors=[chopper])
+response = query_engine.query("When was the Eiffel Tower completed?")
+for n in response.source_nodes:   # one TextNode per chop, SOURCE relationship -> the retrieved node
+    print(n.node.text, n.node.metadata["chop_start"], n.node.metadata["chop_end"])
+# or directly: chopper.postprocess_nodes(nodes, query_str="...")
+```
+
+## Haystack (2.x and later)
+
+```python
+from haystack import Pipeline
+from chopper_rag.haystack import ChopperDocumentCompressor
+
+pipe = Pipeline()
+pipe.add_component("retriever", retriever)                          # any retriever, top_k=16
+pipe.add_component("chopper", ChopperDocumentCompressor(variant="base"))
+pipe.connect("retriever.documents", "chopper.documents")
+out = pipe.run({"retriever": {"query": q}, "chopper": {"query": q}})
+print([d.content for d in out["chopper"]["documents"]], out["chopper"]["decision"])
+```
+
+## Output metadata (all three frameworks)
+
+One output document / node per chop, in passage order. Metadata = the source's metadata plus:
+
+| key | meaning |
+|---|---|
+| `chop_start`, `chop_end` | character offsets of the chop in the source text |
+| `source_index` | position of the source in the input list |
+| `chop_score` | mean p(KEEP) over the chop's tokens |
+| `source_id` | (Haystack only) id of the source Document |
+
+The score of each output is the score of its source. The last ANSWER / SEARCH decision is in `last_decision`
+(LangChain, LlamaIndex) or in the `decision` output (Haystack). A source with no chops produces no output; if nothing
+is kept, the result is empty (usually together with `SEARCH`).
+
+## Details
+
+- Input: `Question: <q> [SEP] <passage 1> [SEP] ... [SEP] <passage N>`, up to 8,192 tokens. Decoding: keep tokens
+  with p(KEEP) > 0.5, merge runs at most 5 tokens apart, drop runs shorter than 4 tokens (from `chopper_config.json`;
+  `threshold=` overrides the cut-off: lower keeps more).
+- Inputs longer than 8,192 tokens are processed in several passes: passages are packed in order into groups that fit
+  next to the question, and a single passage longer than the budget is cut into token windows. Offsets always refer
+  to the original passage. The model was trained on ~20 passages of ~1,000 characters, which fit one pass.
+- Leading/trailing whitespace of a passage is ignored; offsets still refer to the unstripped text.
+- Device: `"auto"` = CUDA if available (bfloat16), else CPU (float32). Pass `repo=` a local directory holding
+  `mmbert-base/` / `mmbert-small/` to run offline.
+
+## Tests
+
+```bash
+pip install -e ".[all,test]"
+CUDA_VISIBLE_DEVICES="" pytest tests/          # uses mmbert-small; CHOPPER_VARIANT=base for the base model
+```
+
+License: MIT.

chopper_rag-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+chopper_rag/__init__.py,sha256=wThJNRAW0nFb152LTxCoJQLoQa3aLILtrgwJG3h3Vxo,544
+chopper_rag/core.py,sha256=kl-8x-Fk9-VHzvXO9CpboxxwCaPhjW7uTnpLw5xNBN0,10702
+chopper_rag/haystack.py,sha256=heoj4u4waTiJpYv5jvPalv0UKqotYKclWwHxcMrIHT4,2375
+chopper_rag/langchain.py,sha256=WKsSaoo0kfyvNiclmrJDj2Dx1PODmLw9cv4QmVmM8is,2070
+chopper_rag/llama_index.py,sha256=SowzmbpgUQ5j_BKIlBm2-rv8D3S42txO_Nx87D_2OoM,3007
+chopper_rag-0.1.0.dist-info/licenses/LICENSE,sha256=xNNl68cH3htTFL1IWaVjDE_BAnzqep_vNkaVJImRB-A,1065
+chopper_rag-0.1.0.dist-info/METADATA,sha256=htMDHZA07-F1GVqP8_kOkDLA7hea5cmKZfHzvFH4iz0,6387
+chopper_rag-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chopper_rag-0.1.0.dist-info/top_level.txt,sha256=gtROUkgtMmiwqkAHozguhJEm-e2WRxbsMZbnFTiTco4,12
+chopper_rag-0.1.0.dist-info/RECORD,,

chopper_rag-0.1.0.dist-info/WHEEL

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

chopper_rag-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wiiiktor
+
+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.

chopper_rag-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+chopper_rag