ragx-cli 0.1.0__py3-none-any.whl

ragx/providers/openai_compat.py

@@ -0,0 +1,117 @@
+"""OpenAI-compatible HTTP providers: works with LM Studio, Ollama's /v1, and OpenAI itself."""
+
+from __future__ import annotations
+
+import time
+from typing import Sequence
+
+import httpx
+
+from ragx.core.errors import RagxError
+
+_MAX_RETRIES = 3
+
+
+def _post_with_retry(client: httpx.Client, url: str, payload: dict) -> dict:
+    last_exc: Exception | None = None
+    for attempt in range(_MAX_RETRIES):
+        try:
+            resp = client.post(url, json=payload)
+            if resp.status_code >= 500:
+                last_exc = RagxError(f"{url} returned {resp.status_code}: {resp.text}")
+            else:
+                resp.raise_for_status()
+                return resp.json()
+        except httpx.ConnectError as exc:
+            last_exc = exc
+        if attempt < _MAX_RETRIES - 1:
+            time.sleep(2**attempt * 0.01)
+    raise RagxError(f"request to {url} failed after {_MAX_RETRIES} attempts: {last_exc}")
+
+
+class OpenAICompatEmbedder:
+    """Embedder implementing providers.base.Embedder against an OpenAI-compatible /embeddings API."""
+
+    model: str
+
+    def __init__(
+        self,
+        base_url: str,
+        model: str,
+        doc_prefix: str = "",
+        query_prefix: str = "",
+        api_key: str | None = None,
+        batch_size: int = 32,
+        timeout: float = 120.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self.doc_prefix = doc_prefix
+        self.query_prefix = query_prefix
+        self.batch_size = batch_size
+        headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+        self._client = httpx.Client(timeout=timeout, headers=headers)
+        self._dim: int | None = None
+
+    def dimension(self) -> int:
+        if self._dim is None:
+            vecs = self._embed_raw(["probe"])
+            self._dim = len(vecs[0])
+        return self._dim
+
+    def embed_documents(self, texts: Sequence[str]) -> list[list[float]]:
+        return self._embed_prefixed(texts, self.doc_prefix)
+
+    def embed_queries(self, texts: Sequence[str]) -> list[list[float]]:
+        return self._embed_prefixed(texts, self.query_prefix)
+
+    def _embed_prefixed(self, texts: Sequence[str], prefix: str) -> list[list[float]]:
+        if not texts:
+            return []
+        return self._embed_raw([f"{prefix}{t}" for t in texts])
+
+    def _embed_raw(self, texts: Sequence[str]) -> list[list[float]]:
+        out: list[list[float]] = []
+        for i in range(0, len(texts), self.batch_size):
+            batch = texts[i : i + self.batch_size]
+            data = _post_with_retry(
+                self._client,
+                f"{self.base_url}/embeddings",
+                {"model": self.model, "input": list(batch)},
+            )
+            out.extend(item["embedding"] for item in data["data"])
+        return out
+
+
+class OpenAICompatGenerator:
+    """Generator implementing providers.base.Generator against an OpenAI-compatible chat API."""
+
+    model: str
+
+    def __init__(
+        self,
+        base_url: str,
+        model: str,
+        api_key: str | None = None,
+        timeout: float = 300.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+        self._client = httpx.Client(timeout=timeout, headers=headers)
+
+    def generate(self, system: str, prompt: str, *, max_tokens: int = 1024) -> str:
+        data = _post_with_retry(
+            self._client,
+            f"{self.base_url}/chat/completions",
+            {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": system},
+                    {"role": "user", "content": prompt},
+                ],
+                "temperature": 0.3,
+                "max_tokens": max_tokens,
+            },
+        )
+        return data["choices"][0]["message"]["content"]

ragx/providers/registry.py

@@ -0,0 +1,81 @@
+"""Factories that build provider instances from Config."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from ragx.core.config import Config
+from ragx.core.errors import RagxError
+from ragx.providers.base import Embedder, Generator, Reranker
+from ragx.providers.openai_compat import OpenAICompatEmbedder, OpenAICompatGenerator
+from ragx.providers.st_reranker import STReranker
+
+_OLLAMA_BASE_URL = "http://localhost:11434/v1"
+# DEFAULTS["embeddings"]["base_url"] — the LM Studio default; if a user switches to the
+# "ollama" provider without also overriding base_url, we swap in the ollama default instead.
+_DEFAULT_OPENAI_BASE_URL = "http://localhost:1234/v1"
+
+
+def _resolve_api_key(cfg: Config, section: str) -> str | None:
+    """`<section>.api_key_env` names an env var (fails loud if unset); otherwise fall back to
+    the conventional OPENAI_API_KEY when present."""
+    env_name = cfg.get(f"{section}.api_key_env")
+    if env_name:
+        key = os.environ.get(env_name)
+        if not key:
+            raise RagxError(
+                f"[{section}] api_key_env = {env_name!r} but that environment variable is not set"
+            )
+        return key
+    return os.environ.get("OPENAI_API_KEY") or None
+
+
+def _resolve_base_url(cfg: Config, section: str) -> str:
+    """Honor the conventional OPENAI_BASE_URL env var, but only while `<section>.base_url`
+    is still the built-in default — an explicit `ragx config set` always wins."""
+    base_url = cfg.get(f"{section}.base_url")
+    env_url = os.environ.get("OPENAI_BASE_URL")
+    if env_url and base_url == _DEFAULT_OPENAI_BASE_URL:
+        return env_url.rstrip("/")
+    return base_url
+
+
+def make_embedder(cfg: Config) -> Embedder:
+    provider = cfg.get("embeddings.provider")
+    base_url = cfg.get("embeddings.base_url")
+    if provider == "openai":
+        base_url = _resolve_base_url(cfg, "embeddings")
+    elif provider == "ollama":
+        if base_url == _DEFAULT_OPENAI_BASE_URL:
+            base_url = _OLLAMA_BASE_URL
+    else:
+        raise RagxError(f"unknown embeddings provider: {provider!r}")
+    return OpenAICompatEmbedder(
+        base_url=base_url,
+        model=cfg.get("embeddings.model"),
+        doc_prefix=cfg.get("embeddings.doc_prefix"),
+        query_prefix=cfg.get("embeddings.query_prefix"),
+        batch_size=cfg.get("embeddings.batch_size"),
+        api_key=_resolve_api_key(cfg, "embeddings"),
+    )
+
+
+def make_generator(cfg: Config) -> Generator | None:
+    if not cfg.get("expansion.enabled"):
+        return None
+    return OpenAICompatGenerator(
+        base_url=_resolve_base_url(cfg, "expansion"),
+        model=cfg.get("expansion.model"),
+        api_key=_resolve_api_key(cfg, "expansion"),
+    )
+
+
+def make_reranker(cfg: Config) -> Reranker | None:
+    if not cfg.get("rerank.enabled"):
+        return None
+    try:
+        return STReranker(model=cfg.get("rerank.model"))
+    except RagxError as exc:
+        print(f"warning: reranker unavailable: {exc}", file=sys.stderr)
+        return None

ragx/providers/st_reranker.py

@@ -0,0 +1,28 @@
+"""Cross-encoder reranker backed by sentence-transformers (optional extra)."""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from ragx.core.errors import RagxError
+
+
+class STReranker:
+    """Reranker implementing providers.base.Reranker via a sentence-transformers CrossEncoder."""
+
+    model: str
+
+    def __init__(self, model: str) -> None:
+        try:
+            from sentence_transformers import CrossEncoder
+        except ImportError as exc:
+            raise RagxError(
+                "sentence-transformers not installed — install with: uv pip install 'ragx[rerank]'"
+            ) from exc
+        self.model = model
+        self._encoder = CrossEncoder(model)
+
+    def score(self, query: str, texts: Sequence[str]) -> list[float]:
+        pairs = [[query, text] for text in texts]
+        scores = self._encoder.predict(pairs)
+        return [float(s) for s in scores]

ragx_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,297 @@
+Metadata-Version: 2.4
+Name: ragx-cli
+Version: 0.1.0
+Summary: Similarity-graph RAG CLI: index a corpus into a chunk-level embedding graph and query it
+Project-URL: Repository, https://github.com/alber70g/ragx-cli
+Project-URL: Issues, https://github.com/alber70g/ragx-cli/issues
+Author-email: Albert Groothedde <albertgroothedde@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,embeddings,rag,retrieval,search,similarity-graph
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.12
+Requires-Dist: hnswlib>=0.8
+Requires-Dist: httpx>=0.27
+Requires-Dist: pathspec>=0.12
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: typer>=0.12
+Requires-Dist: xxhash>=3.4
+Provides-Extra: rerank
+Requires-Dist: sentence-transformers>=3.0; extra == 'rerank'
+Description-Content-Type: text/markdown
+
+# ragx-cli — similarity-graph RAG for your files
+
+`ragx-cli` indexes a corpus of files into a **chunk-level embedding similarity graph** and answers
+queries by combining vector search, **graph traversal**, and **cross-encoder reranking** — all
+from a single local CLI. Indexing needs **no LLM** (only an embedding model); an LLM is used
+optionally at query time, for query expansion.
+
+It works on any directory of text: pair it with a
+[Karpathy-style LLM Wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f),
+an OpenWiki instance, an Obsidian-style notes vault, or any other knowledgebase repository or
+arbitrary docs/code tree — `ragx-cli init` drops a `.ragx/` directory next to the files and
+everything else stays untouched. LLM-maintained wikis and ragx-cli are complementary: the wiki
+distills knowledge into curated pages, while ragx-cli gives agents fast graph-backed retrieval
+over those pages (and the raw sources beside them) without re-reading everything per question.
+
+**The goal:** local semantic search that finds documents *plain vector search misses*, stays
+cheap to (re)index, and is built to be driven by coding agents as much as by humans — stable
+JSON schemas, deterministic exit codes, byte-exact source locations, and an `--explain` mode
+that can justify every result via the exact graph path that produced it.
+
+```bash
+uv tool install ragx-cli       # or run one-off without installing: uvx ragx-cli ...
+ragx-cli init                  # create .ragx/ with config.toml next to your corpus
+ragx-cli index                 # chunk -> embed -> HNSW + kNN similarity graph
+ragx-cli query "why did we switch build tools?" --json --files-only
+ragx-cli index --changed       # incremental: only new/modified/deleted files
+```
+
+Runs against any OpenAI-compatible embedding endpoint (LM Studio, Ollama, OpenAI). Reranking
+uses a local sentence-transformers cross-encoder (`ragx-cli[rerank]` extra). Everything lives in a
+`.ragx/` directory beside your files — like `.git/`, delete it and the corpus is untouched.
+
+---
+
+- [ragx-cli — similarity-graph RAG for your files](#ragx-cli--similarity-graph-rag-for-your-files)
+  - [How it works](#how-it-works)
+    - [Indexing (LLM-free)](#indexing-llm-free)
+    - [Querying](#querying)
+  - [Does it actually help? (benchmarks)](#does-it-actually-help-benchmarks)
+  - [Agent-first conventions](#agent-first-conventions)
+  - [Using ragx-cli from a coding agent (CLAUDE.md / AGENTS.md)](#using-ragx-cli-from-a-coding-agent-claudemd--agentsmd)
+    - [Pointing ragx-cli at your LLM — local or online](#pointing-ragx-cli-at-your-llm--local-or-online)
+  - [Configuration](#configuration)
+  - [Features & roadmap](#features--roadmap)
+
+
+## How it works
+
+### Indexing (LLM-free)
+
+Files are chunked structure-aware (markdown headings / code boundaries / recursive fallback),
+embedded, and stored in an HNSW index. The similarity graph then falls out almost for free:
+one kNN pass over the vectors that are already in memory — each chunk gets edges to its top-k
+nearest neighbors above a similarity floor.
+
+```mermaid
+flowchart TD
+    A[files] --> B["discover + hash<br/>(gitignore, binary/junk filters,<br/>xxhash for incremental)"]
+    B --> C["chunk<br/>(headings / code boundaries,<br/>byte-exact slices + line ranges)"]
+    C --> D["embed<br/>(any OpenAI-compatible endpoint)"]
+    D --> E[("HNSW index<br/>vectors.hnsw")]
+    D --> F[("SQLite<br/>files · chunks · edges · manifest")]
+    E -- "kNN per chunk<br/>(k=8, cos ≥ 0.55)" --> G["similarity graph<br/>undirected weighted edges"]
+    G --> F
+```
+
+Incremental runs (`--changed`) re-embed only changed files and repair only the edge lists that
+those chunks touch. Content hashes make `touch`-ed but unchanged files free.
+
+### Querying
+
+Every stage is individually skippable (`--no-expand`, `--no-graph`, `--no-rerank`) so callers
+can trade quality for latency.
+
+```mermaid
+flowchart TD
+    Q[query] --> X["1 · expansion (optional, one LLM call)<br/>2–4 reformulations + HyDE passage"]
+    X --> S["2 · fan-out vector search<br/>top-20 per variant"]
+    Q -. "--no-expand" .-> S
+    S --> R["3 · Reciprocal Rank Fusion<br/>merged seed set"]
+    R --> H["4 · heat propagation over the graph<br/>2 hops · decay 0.5 · max-aggregation<br/>query-similarity floor · frontier cap"]
+    R -. "--no-graph" .-> K
+    H --> K["5 · cross-encoder rerank<br/>(query, chunk) pairs, capped shortlist"]
+    K --> F["6 · combined score<br/>α·rerank + β·heat + γ·vector"]
+    F --> O["ranked chunks (or files via --files-only)<br/>+ --explain traversal trace"]
+```
+
+**Heat propagation** is what sets ragx-cli apart from plain RAG: seed chunks (from vector search)
+push "heat" along similarity edges — `heat × edge_weight × decay` per hop. A neighbor's heat is
+the **max** of incoming contributions (not the sum, so hub chunks can't inflate themselves), and
+a neighbor is only admitted if it's similar enough to the *original query* — traversal stays
+anchored to the question instead of drifting through the corpus.
+
+```mermaid
+flowchart LR
+    subgraph seeds["seeds (vector hits)"]
+        S1["chunk A · heat 1.0"]
+    end
+    S1 -- "edge 0.86" --> N1["chunk B<br/>heat = 1.0 × 0.86 × 0.5 = 0.43"]
+    N1 -- "edge 0.70" --> N2["chunk C<br/>heat = 0.43 × 0.70 × 0.5 = 0.15"]
+    S1 -- "edge 0.60" --> X1["chunk D — below query floor<br/>✗ not admitted, doesn't relay"]
+```
+
+Because every admitted chunk records which seed and edge produced it, `--explain` can print the
+full justification: *seed → edge(weight) → chunk*, per result.
+
+---
+
+## Does it actually help? (benchmarks)
+
+Measured with the built-in harness (`ragx-cli eval queries.jsonl`) on a real, decade-spanning
+personal wiki — organic notes, not a synthetic benchmark. Corpus provenance:
+
+| | |
+|---|---|
+| **corpus** | 636 markdown files indexed (644 on disk; 8 auto-excluded as `node_modules`/hidden) · 2.9 MB · avg 4.6 KB/file |
+| **structure** | topical top-level dirs (`clients/`, `projects/`, `workstreams/`, `personal/`, …), nested up to 10 levels deep |
+| **content** | mixed **English + Dutch**: meeting/daily notes, research docs, transcripts, reference material |
+| **chunks** | 1,323 (avg 2.1 per file, 452 files are single-chunk; median 2,390 chars ≈ 600 tokens, max 4,888) |
+| **graph** | 5,246 edges · avg degree 7.9 (k=8 cap) · weights 0.59–1.00 above the 0.55 floor · only 3 isolated chunks |
+| **index** | 5.1 MB SQLite + 4.1 MB HNSW (768-dim `nomic-embed-text-v1.5` via LM Studio) · full build ≈ 2 min on an M-series laptop |
+| **labels** | 18 queries (EN + NL) with known-relevant files, single- and multi-target (`.ragx/queries.jsonl`) |
+
+Reranker: `BAAI/bge-reranker-v2-m3` (local cross-encoder). Results:
+
+| config                           | recall@5 | recall@10 |       MRR |
+| -------------------------------- | -------: | --------: | --------: |
+| `baseline` — vector search only  |    0.833 |     0.833 |     0.593 |
+| `graph` — + heat propagation     |    0.778 |     0.833 |     0.522 |
+| `rerank` — graph + cross-encoder |    0.759 | **0.889** |     0.568 |
+| `full` — + LLM expansion         |    0.759 | **0.889** | **0.613** |
+
+The recall win is exactly the designed mechanism, and it's traceable. For one Dutch query
+("zonnepanelen offerte en terugverdientijd"), the relevant document is **never retrieved** by
+vector search — and a reranker alone can't help, because you can't rerank what retrieval never
+surfaced:
+
+| pipeline                 | rank of the relevant file |
+| ------------------------ | ------------------------: |
+| vector search only       |               *not found* |
+| rerank **without** graph |               *not found* |
+| graph only               |                        19 |
+| graph **+** rerank       |                     **4** |
+
+The graph surfaced it through a single hop-1 edge (weight 0.86) from a seed chunk, and the
+cross-encoder promoted it — *graph expands recall, rerank recovers precision*. The `--explain`
+output for that result shows the exact seed → edge → chunk path.
+
+**Honest caveat:** graph traversal *alone* hurts precision on this corpus (MRR 0.593 → 0.522) —
+near-duplicate neighbors (e.g. adjacent meeting notes) displace weaker direct hits. A parameter
+sweep over decay/floor/weights plateaued below baseline MRR, so this is a property of
+similarity-only edges, not a tuning miss. Conclusion baked into the defaults: **graph and
+rerank ship together**. Use `--no-graph --no-rerank` as the explicit fast mode.
+
+---
+
+## Agent-first conventions
+
+- `--json` emits exactly one JSON document on stdout (versioned schemas: `ragx.query.v1`,
+  `ragx.files.v1`, `ragx.status.v1`, `ragx.eval.v1`, `ragx.inspect.*.v1`); logs go to stderr.
+- Exit codes: `0` results, `1` success-but-empty, `2` error.
+- Every chunk carries `file`, `line_start/line_end`, `byte_start/byte_end` — agents jump to the
+  exact source location and read the full text themselves (JSON chunk text is truncated).
+- `--files-only` aggregates chunk scores per file (sum of top-3) — the mode coding agents use most.
+- `ragx-cli query -` reads the query from stdin; `ragx-cli inspect chunk|file|neighbors` debugs the graph.
+
+## Using ragx-cli from a coding agent (CLAUDE.md / AGENTS.md)
+
+Give your agent standing instructions by pasting this into the repo's `CLAUDE.md` or `AGENTS.md`
+(adjust the fenced block to your corpus):
+
+```markdown
+## Semantic search with ragx-cli
+
+This repo has a ragx-cli index (`.ragx/`). Prefer it over grep for "where is X discussed/decided?"
+questions; fall back to grep for exact identifiers.
+
+- Find relevant files: `ragx-cli query "<natural-language question>" --json --files-only`
+- Get chunks with exact locations: `ragx-cli query "..." --json --top 8` — each result carries
+  `file` + `line_start/line_end`; the JSON `text` is truncated, so read the file yourself
+  for full context.
+- Fast mode (no LLM call, no cross-encoder): add `--no-expand --no-rerank`.
+- After adding or editing files: `ragx-cli index --changed` (cheap, hash-based).
+- stdout is exactly one JSON document; logs are on stderr.
+  Exit codes: 0 = results, 1 = no results (not an error), 2 = error.
+- Why did this result appear? `ragx-cli query "..." --explain`.
+  Explore the graph: `ragx-cli inspect neighbors <chunk_id>`.
+```
+
+### Pointing ragx-cli at your LLM — local or online
+
+ragx-cli talks to any **OpenAI-compatible** API for embeddings and (optionally) query expansion.
+Pick one recipe; run it inside the corpus after `ragx-cli init`:
+
+**LM Studio** (default — nothing to change if it runs on `localhost:1234`):
+
+```bash
+curl -s http://localhost:1234/v1/models   # see what's loaded
+ragx-cli config set embeddings.model text-embedding-nomic-embed-text-v1.5
+ragx-cli config set expansion.model  <any-chat-model-id>     # or: ragx-cli config set expansion.enabled false
+```
+
+**Ollama** (base_url switches to `localhost:11434/v1` automatically):
+
+```bash
+ollama pull nomic-embed-text
+ragx-cli config set embeddings.provider ollama
+ragx-cli config set embeddings.model nomic-embed-text
+ragx-cli config set expansion.provider ollama
+ragx-cli config set expansion.model llama3.1                  # any local chat model
+```
+
+**Online / any OpenAI-compatible endpoint** (OpenAI, OpenRouter, Together, …).
+ragx-cli honors the conventional env vars used by generic OpenAI-compatible tooling — with
+`OPENAI_BASE_URL` and `OPENAI_API_KEY` exported, only the model names need configuring:
+
+```bash
+export OPENAI_BASE_URL=https://api.openai.com/v1
+export OPENAI_API_KEY=sk-...
+ragx-cli config set embeddings.model text-embedding-3-small
+ragx-cli config set embeddings.doc_prefix ""                  # prefixes are for nomic-style models
+ragx-cli config set embeddings.query_prefix ""
+ragx-cli config set expansion.model gpt-5.2-mini
+```
+
+Precedence rules (per section, embeddings and expansion independently):
+
+- `base_url`: an explicit `ragx-cli config set <section>.base_url …` always wins;
+  `OPENAI_BASE_URL` applies only while the config still holds the built-in default.
+- API key: `ragx-cli config set <section>.api_key_env MY_VAR` names an env var to read (and fails
+  loudly if that variable is unset); without it, `OPENAI_API_KEY` is used when present.
+  Secrets themselves never go in `config.toml`.
+
+Mixed setups are normal — e.g. local Ollama embeddings + online expansion via
+`ragx-cli config set expansion.base_url https://openrouter.ai/api/v1` +
+`ragx-cli config set expansion.api_key_env OPENROUTER_API_KEY`. The reranker is always local
+(sentence-transformers); disable it with `ragx-cli config set rerank.enabled false` if the model
+download is unwanted. **Note:** changing the embedding model invalidates the index — ragx-cli
+detects the mismatch and asks you to run a full `ragx-cli index`.
+
+## Configuration
+
+`.ragx/config.toml`, managed via `ragx-cli config get|set`. Key defaults:
+
+| section | defaults |
+|---|---|
+| `[chunking]` | `size_tokens=800`, `overlap=0.15` |
+| `[graph]` | `k=8`, `min_edge_sim=0.55` |
+| `[traversal]` | `hops=2`, `decay=0.5`, `query_floor=0.35`, `max_frontier=150` |
+| `[fusion]` | `rrf_k=60`, `per_query_top=20` |
+| `[scoring]` | `alpha_rerank=0.6`, `beta_heat=0.25`, `gamma_vector=0.15` |
+| `[embeddings]` | `provider="openai"`, `base_url="http://localhost:1234/v1"`, prefixes for nomic-style models, `api_key_env=""` |
+| `[expansion]` | optional LLM for multi-query/HyDE; reasoning models supported (4096-token budget); `api_key_env=""` |
+| `[rerank]` | `BAAI/bge-reranker-v2-m3` via sentence-transformers (`uv tool install 'ragx-cli[rerank]'`) |
+
+## Features & roadmap
+
+Checked features are built and validated per [the implementation plan](ragx-cli-plan.md);
+unchecked ones are next up:
+
+- [x] **CLI & storage**: typer CLI, SQLite schema, provider abstraction (Embedder/Generator/Reranker)
+- [x] **Baseline vector RAG**: discovery, chunking, embeddings, HNSW search, incremental `--changed`
+- [x] **Similarity graph**: kNN edge construction, heat-propagation traversal, `inspect`, `--explain`
+- [x] **Quality & measurement**: multi-query/HyDE expansion, RRF fusion, cross-encoder rerank, `eval` harness
+- [ ] **Communities**: Leiden detection over the edge list, `query --global` for corpus-level questions
+- [ ] **MCP server**: a second thin shell over `ragx.core` (the core/CLI split it needs is already enforced)
+- [ ] **[Temporal weighting](docs/feature-temporal-weighting.md)**: opt-in `--since`/`--until`/`--temporal recent|oldest`, date cascade filename/frontmatter → git → mtime
+- [ ] **Release**: publish to PyPI as `ragx-cli` (plain `ragx` is name-blocked, too similar to an existing project) so `uvx ragx-cli` works out of the box
+
+Development: `uv sync --group dev && uv run pytest`. 126 tests; module contracts live in
+`CONTRACTS.md` / `CONTRACTS-PHASE23.md`.

ragx_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+ragx/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+ragx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragx/cli/app.py,sha256=JF34OKekTU9Z8hHqPdQcltYKJUFzh5nhHq0oYllRrd8,2984
+ragx/cli/eval_cmd.py,sha256=enrl4zfwFXjzI7n5oJ5B07SY_Wz3giDRzlyvhL9oB7Y,2717
+ragx/cli/inspect_cmd.py,sha256=TLdclQ48lAymC9rzbGOC-wlcKKx1Rw-lW-nY6P3PKLA,4167
+ragx/cli/output.py,sha256=PA_nX9eE0aiBx8pLVxa2fY7eOA-kiHwrNN5n-9f1CnU,567
+ragx/cli/pipeline.py,sha256=ma8Cw2bTcrYJzR9AS2vptS0dARqSBttqake25-Jlo3U,3422
+ragx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragx/core/chunking.py,sha256=EBGbGXMgc1Acja6Xzz5dYejPhKXQez64TS7NSV_tDa4,6194
+ragx/core/config.py,sha256=-5_1n_VvDJbSU37F9ldsCiCMu6LX4yu94zD4RDJ3-XU,4460
+ragx/core/discovery.py,sha256=UE1CtePKwynbK4VTfcEg4Hch7PrwhDLKcRgxpbzKM94,2571
+ragx/core/errors.py,sha256=9pZXyLsoy8DSGleCofHownQAn5OhzYJUANrMKNlaq8I,328
+ragx/core/eval.py,sha256=G-CLqYuLTmhjd52ojL4xhX1IeD-2alHWCWrdSwnc_BM,3221
+ragx/core/expansion.py,sha256=mePowcU_ax_AROsxVlv9WXr81LdUkY0A7iyQQG_ajMc,3031
+ragx/core/fusion.py,sha256=5ONs68KybSCxT3AolIR_aI5feXtjHfPkLfhEKfIn788,499
+ragx/core/graph.py,sha256=s5LebTT77orOAMYgkrhZApoESsRHr6OUpW9jYHoNMR0,1285
+ragx/core/indexer.py,sha256=_UK7cYerJgIPRTS17tXuelM5fDwAk_VOv5WHw8TvAIo,4578
+ragx/core/models.py,sha256=jpEfU_LIbleMB7Xe-a1w5BAYQax73bwsNAFcVSb6rbM,1657
+ragx/core/query.py,sha256=L4_FcJLKgTL9Y98IE-zRJ3fWIAuhSYnUxmM9MZpY6ZM,7102
+ragx/core/scoring.py,sha256=SyqWiipAQbbG3p01RrDeomgRKnUONvGo9__5mIH7zHs,1520
+ragx/core/store.py,sha256=a28fIrnk8fTIelUP7Cc9m1CIB4nkHkZbgoP-Cn48gH8,6536
+ragx/core/traversal.py,sha256=x4Buk9bGDOt76AalJ3CUVeLaDFtYerFLaMzlfCm_bf0,2224
+ragx/core/vectors.py,sha256=3frTPe_kajAa22gfeycrN9YdT_Z1ED_TvZQDfM2Z0AA,3779
+ragx/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragx/providers/base.py,sha256=TbXHKULuBMtrz7ba1IE3gMvPRl2CI_EKN6o9-_I-4sY,1383
+ragx/providers/openai_compat.py,sha256=hM3pQJl6a8lVxVAbIiA3TGHtD1uFNaDwM2L4C2Fga_s,3908
+ragx/providers/registry.py,sha256=huLf1Q55jHSpi4wWtQFxgpjbMQynDs5BBhDzeQ-zkBo,3015
+ragx/providers/st_reranker.py,sha256=aWC_J13W_0p3uP_Gv1acWZ49jHfF0pPOOX2fkJKLUq4,904
+ragx_cli-0.1.0.dist-info/METADATA,sha256=I7PRU_Czy9vPLGs2O43vZT5v3I4m2VfjFeffEV0Q3pA,15840
+ragx_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+ragx_cli-0.1.0.dist-info/entry_points.txt,sha256=DnzUStJpxrAZKXJV6vkXUomgWIU45hBzmLRfdsFa1yo,47
+ragx_cli-0.1.0.dist-info/licenses/LICENSE,sha256=rDLbA2XooXRy7qm4a2OaILIq3fSKh__wiHwSqiJJWCg,1074
+ragx_cli-0.1.0.dist-info/RECORD,,

ragx_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ragx_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ragx-cli = ragx.cli.app:main

ragx_cli-0.1.0.dist-info/licenses/LICENSE

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