Add files using upload-large-folder tool

data/bm25/documents/part-000020.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5b807e6d3d973dd9ee951ec5c1651e8144a10b51353535b6844ce467cf35c58e
-size 256413
+oid sha256:d68542a02ae1688305793a6e855e90339839a4145afb1614748cd66f843d7a13
+size 359713

manifest.json

@@ -1,58 +1,52 @@
 {
-  "schema_version": "skillcenter-huggingface-release/v3",
-  "packager_version": "0.1.0",
-  "primary_key": "entry_cid",
-  "dataset_id": "endomorphosis/ipfs_argentina_laws",
-  "dataset_repo_id": "justicedao/ipfs_argentina_laws-ir",
-  "dataset_revision": "0361102728979d41f9e2953f8b03fcc4243d3039",
-  "country": {
-    "slug": "argentina",
-    "repo": "endomorphosis/ipfs_argentina_laws",
-    "name": "Argentina",
-    "indexable": true
-  },
-  "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
   "bm25": {
-    "k1": 1.2,
+    "average_document_length": 326.36434898797444,
     "b": 0.75,
-    "title_weight": 5.0,
     "body_weight": 1.0,
-    "average_document_length": 326.36434898797444,
-    "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1",
+    "k1": 1.2,
     "max_query_terms": 64,
     "posting_rows_per_record": 4096,
-    "terms_per_shard": 4096
+    "terms_per_shard": 4096,
+    "title_weight": 5.0,
+    "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1"
+  },
+  "country": {
+    "indexable": true,
+    "name": "Argentina",
+    "repo": "endomorphosis/ipfs_argentina_laws",
+    "slug": "argentina"
   },
   "counts": {
     "bm25_document_chunks": 25,
     "bm25_documents": 101035,
     "bm25_keyword_shards": 22,
     "bm25_posting_rows": 86888,
+    "bm25_posting_shards": 22,
     "bm25_postings": 9327357,
     "bm25_terms": 86072,
     "corpus_chunks": 25,
     "corpus_rows": 101035,
+    "corpus_shards": 25,
     "graph_edge_chunks": 251,
     "graph_edges": 1025923,
     "graph_incoming_adjacency_edges": 1025923,
     "graph_incoming_adjacency_rows": 101348,
     "graph_incoming_adjacency_shards": 25,
     "graph_node_chunks": 27,
+    "graph_node_shards": 27,
     "graph_nodes": 109681,
     "graph_outgoing_adjacency_edges": 1025923,
     "graph_outgoing_adjacency_rows": 101035,
     "graph_outgoing_adjacency_shards": 25,
-    "vector_chunks": 25,
-    "vector_rows": 101035,
+    "n_articles": 92392,
     "n_laws": 8643,
-    "n_articles": 92392
-  },
-  "parquet": {
-    "compression": "zstd",
-    "compression_level": 6,
-    "max_rows_per_file": 4096,
-    "row_group_size": 4096
+    "vector_chunks": 25,
+    "vector_rows": 101035
   },
+  "dataset_id": "endomorphosis/ipfs_argentina_laws",
+  "dataset_repo_id": "justicedao/ipfs_argentina_laws-ir",
+  "dataset_revision": "0361102728979d41f9e2953f8b03fcc4243d3039",
+  "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
   "graph": {
     "adjacency_pointers_per_row": 4096,
     "adjacency_pointers_per_shard": 8192,
@@ -60,8 +54,6 @@
       "incoming",
       "outgoing"
     ],
-    "max_remote_walk_depth": 8,
-    "ordering": "score_desc_nulls_last",
     "edge_types": [
       "HAS_JURISDICTION",
       "HAS_LAW_ID",
@@ -69,107 +61,220 @@
       "HAS_SOURCE",
       "BM25_NEIGHBOR_OF",
       "CONTAINED_IN"
-    ]
-  },
-  "vector": {
-    "model_name": "thenlper/gte-small",
-    "dimension": 384,
-    "similarity": "cosine",
-    "assignment": "recursive_spherical_kmeans",
-    "layout": "semantic_centroid_groups",
-    "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
-    "max_rows_per_chunk": 4096,
-    "max_rows_per_centroid": 8192,
-    "max_shards_per_centroid": 2,
-    "default_probe_centroids": 4,
-    "centroid_count": 38,
-    "shard_count": 38,
-    "n_vectors": 101035
-  },
-  "schema_mapping": {
-    "laws": {
-      "id": "source_id / law_id",
-      "title": "title",
-      "text": "body",
-      "article_count_dtype_source": "int32"
-    },
-    "articles": {
-      "id": "source_id / article_id",
-      "law_id": "law_id / parent_law_id",
-      "title": "title",
-      "text": "body"
-    },
-    "required_law_columns": [
-      "id",
-      "title",
-      "text"
     ],
-    "required_article_columns": [
-      "id",
-      "law_id",
-      "title",
-      "text"
-    ],
-    "fail_closed": true,
-    "notes": "Malta and Germany share the same column names. Drift: Malta article_count is int64, Germany article_count is int32; Germany eli is often null. Identifiers are never invented."
+    "max_remote_walk_depth": 8,
+    "ordering": "score_desc_nulls_last"
   },
   "indexes": {
     "bm25_document_chunks": {
       "cid": "bafkreigy5mkwikyr32y7ueh66ilgi7mko5qahm5mwhhzm3augoigiumuf4",
-      "sha256": "d8eb15642b11deb1fa10fef216647d8a776003b3acb1cf966c1433906451942f",
-      "size_bytes": 12624,
-      "relative_path": "indexes/bm25_document_chunks.parquet"
+      "content_cid": "bafkreid5al6p6ovnezsjrzbrgr3o26mdx7tykgpedujclrwiijwslf2rbq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_document_chunks.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "7d02fcff3aad266498e4313476ed7983bfe78519e41d1225c6c8426d2597510c",
+      "size_bytes": 9434
+    },
+    "bm25_documents": {
+      "content_cid": "bafkreid5al6p6ovnezsjrzbrgr3o26mdx7tykgpedujclrwiijwslf2rbq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_document_chunks.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "7d02fcff3aad266498e4313476ed7983bfe78519e41d1225c6c8426d2597510c",
+      "size_bytes": 9434
+    },
+    "bm25_keyword_index": {
+      "content_cid": "bafkreie6sa2r7fwsg4ytqvgt7gdac6jrqy5mxje6cd35atgfxyxfqpxsbi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 22,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "9e90351f96d237313854d3f986017931863acba49e10f7d04cc5be2e583ef20a",
+      "size_bytes": 7243
     },
     "bm25_keyword_shards": {
       "cid": "bafkreietej6aj43v4jlcuiw47uzl334nfiwopiypwwewh56xhi2f7gryke",
-      "sha256": "93227c04f375e2562a22dcfd32bdef8d2a2ce7a30fb58963f7d73a345f9a3851",
-      "size_bytes": 12540,
-      "relative_path": "indexes/bm25_keyword_shards.parquet"
+      "content_cid": "bafkreie6sa2r7fwsg4ytqvgt7gdac6jrqy5mxje6cd35atgfxyxfqpxsbi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 22,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "9e90351f96d237313854d3f986017931863acba49e10f7d04cc5be2e583ef20a",
+      "size_bytes": 7243
+    },
+    "bm25_postings": {
+      "content_cid": "bafkreie6sa2r7fwsg4ytqvgt7gdac6jrqy5mxje6cd35atgfxyxfqpxsbi",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 22,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "9e90351f96d237313854d3f986017931863acba49e10f7d04cc5be2e583ef20a",
+      "size_bytes": 7243
+    },
+    "corpus": {
+      "content_cid": "bafkreidaksg5ycekzud7qofpyydkc6qighamnam5mxnqiqce3wgqmfiohq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/corpus_chunks.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "60548ddc088acd07f838afc606a17a0831c0c6819d65db044044dd8d06150e3c",
+      "size_bytes": 9354
     },
     "corpus_chunks": {
       "cid": "bafkreickhec272gyjf2kwuwjbtekvbtiu2uyrxgj4pepovr3qnovqzroqi",
-      "sha256": "4a3905afe8d84974ab52c90cc8aa8668a6a988dcc9e3c8f7563b835d58662e82",
-      "size_bytes": 12573,
-      "relative_path": "indexes/corpus_chunks.parquet"
+      "content_cid": "bafkreidaksg5ycekzud7qofpyydkc6qighamnam5mxnqiqce3wgqmfiohq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/corpus_chunks.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "60548ddc088acd07f838afc606a17a0831c0c6819d65db044044dd8d06150e3c",
+      "size_bytes": 9354
     },
     "graph_edge_chunks": {
       "cid": "bafkreiehamnnmqzpforjm4jcnoqxxbrfeacy76xfok24nvh42uuuslon7u",
-      "sha256": "87031ad6432f2ba29671226ba17b862520058ffae572b5c6d4fcd529492dcdfd",
-      "size_bytes": 46309,
-      "relative_path": "indexes/graph_edge_chunks.parquet"
+      "content_cid": "bafkreifbsoeizaa42jt6lorxt5mtqliibt6hzprwoidxoa5puczpibt3y4",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_edge_chunks.parquet",
+      "row_count": 251,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "a193888c801cd267e5ba379f59382d080cfc7cbe3672077703afa0b2f4067bc7",
+      "size_bytes": 50555
+    },
+    "graph_edges": {
+      "content_cid": "bafkreifbsoeizaa42jt6lorxt5mtqliibt6hzprwoidxoa5puczpibt3y4",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_edge_chunks.parquet",
+      "row_count": 251,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "a193888c801cd267e5ba379f59382d080cfc7cbe3672077703afa0b2f4067bc7",
+      "size_bytes": 50555
     },
     "graph_incoming_adjacency": {
       "cid": "bafkreidzjvcwdkr75invd7qvqaiefbsigo4av2fe46xnnjxs6of4w4b7tu",
-      "sha256": "794d4561aa3fea1b51fe15801042864833b80ae8a4e7aed6a6f2f38bcb703f9d",
-      "size_bytes": 15661,
-      "relative_path": "indexes/graph_incoming_adjacency.parquet"
+      "content_cid": "bafkreigivcgunz62mdeqbogwc4xou4mopptnz3tqthjukbup5ftgzz7oyy",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_incoming_adjacency.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "c8a88d46e7da60c900b8d6172eea718e7be6dcee7099d345068fe9666ce7eec6",
+      "size_bytes": 9537
     },
     "graph_node_chunks": {
       "cid": "bafkreigsqcex65xxrzsw72lnvbgl2aypnhwzcz6666p4vmwx3p4ymuxhzm",
-      "sha256": "d280897f76f78e656fe96da84cbd030f69ed9167def79fcab2d7dbf98652e7cb",
-      "size_bytes": 12722,
-      "relative_path": "indexes/graph_node_chunks.parquet"
+      "content_cid": "bafkreibj5i3rsele5yjhqvzegxqofbdstx3yvkzlvf6gwpjolpequypace",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_node_chunks.parquet",
+      "row_count": 27,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "29ea37191164ee1278572435e0e284729df78aab2ba97c6b3d2e5bc90a61e011",
+      "size_bytes": 9696
+    },
+    "graph_nodes": {
+      "content_cid": "bafkreibj5i3rsele5yjhqvzegxqofbdstx3yvkzlvf6gwpjolpequypace",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_node_chunks.parquet",
+      "row_count": 27,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "29ea37191164ee1278572435e0e284729df78aab2ba97c6b3d2e5bc90a61e011",
+      "size_bytes": 9696
     },
     "graph_outgoing_adjacency": {
       "cid": "bafkreid4qjp3dnulzqsac2jy4rteayhfoahmk46u5zkzewfuvzjj7wsley",
-      "sha256": "7c825fb1b68bcc24016938e4664060e5700ec573d4ee559258b4ae529fda4b26",
-      "size_bytes": 15642,
-      "relative_path": "indexes/graph_outgoing_adjacency.parquet"
+      "content_cid": "bafkreieyebvtroxyyvuc3lr5pzr2ms4g5qt3ylpr3t7aazthkzcbslgpoq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_outgoing_adjacency.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "98206b38baf8c5682dae3d7e63a64b86ec27bc2df1dcfe0066675644192ccf74",
+      "size_bytes": 9510
     },
     "vector_chunks": {
       "cid": "bafkreibf2hmove7uqm4xyi5jdvfmw3yrvjm35kgeyscowzg53cqxfiyxii",
-      "sha256": "25d1d8ea93f483397c23a91d4acb6f11aa59bea8c4c484eb64ddd8a172a31742",
-      "size_bytes": 133891,
-      "relative_path": "indexes/vector_chunks.parquet"
+      "content_cid": "bafkreiacgoul6ivkdj7dnbayowxkrysa3sn2gczh7lh65ibfphoxipbrbe",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/vector_chunks.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "0233a8bf22aa1a7e36841875aea8e240dc9ba30b27facfeea02579dd743c3109",
+      "size_bytes": 9324
+    },
+    "vectors": {
+      "content_cid": "bafkreiacgoul6ivkdj7dnbayowxkrysa3sn2gczh7lh65ibfphoxipbrbe",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/vector_chunks.parquet",
+      "row_count": 25,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "0233a8bf22aa1a7e36841875aea8e240dc9ba30b27facfeea02579dd743c3109",
+      "size_bytes": 9324
     }
   },
+  "packager_version": "0.1.0",
+  "parquet": {
+    "compression": "zstd",
+    "compression_level": 6,
+    "max_rows_per_file": 4096,
+    "row_group_size": 4096
+  },
+  "primary_key": "entry_cid",
+  "schema_mapping": {
+    "articles": {
+      "id": "source_id / article_id",
+      "law_id": "law_id / parent_law_id",
+      "text": "body",
+      "title": "title"
+    },
+    "fail_closed": true,
+    "laws": {
+      "article_count_dtype_source": "int32",
+      "id": "source_id / law_id",
+      "text": "body",
+      "title": "title"
+    },
+    "notes": "Malta and Germany share the same column names. Drift: Malta article_count is int64, Germany article_count is int32; Germany eli is often null. Identifiers are never invented.",
+    "required_article_columns": [
+      "id",
+      "law_id",
+      "title",
+      "text"
+    ],
+    "required_law_columns": [
+      "id",
+      "title",
+      "text"
+    ]
+  },
+  "schema_version": "skillcenter-huggingface-release/v3",
   "source": {
-    "source_dataset": "endomorphosis/ipfs_argentina_laws",
-    "source_revision": "0361102728979d41f9e2953f8b03fcc4243d3039",
-    "laws_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_argentina_laws/snapshots/0361102728979d41f9e2953f8b03fcc4243d3039/data/laws.parquet",
+    "article_count_dtype": "int32",
+    "articles_columns": [
+      "law_id",
+      "id",
+      "title",
+      "text",
+      "source_url",
+      "document_number",
+      "article_number",
+      "record_type",
+      "metadata_json"
+    ],
     "articles_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_argentina_laws/snapshots/0361102728979d41f9e2953f8b03fcc4243d3039/data/articles.parquet",
-    "n_laws_source": 8643,
-    "n_articles_source": 92507,
     "laws_columns": [
       "id",
       "title",
@@ -191,17 +296,25 @@
       "json_path",
       "metadata_json"
     ],
-    "articles_columns": [
-      "law_id",
-      "id",
-      "title",
-      "text",
-      "source_url",
-      "document_number",
-      "article_number",
-      "record_type",
-      "metadata_json"
-    ],
-    "article_count_dtype": "int32"
+    "laws_path": "/workspace/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_argentina_laws/snapshots/0361102728979d41f9e2953f8b03fcc4243d3039/data/laws.parquet",
+    "n_articles_source": 92507,
+    "n_laws_source": 8643,
+    "source_dataset": "endomorphosis/ipfs_argentina_laws",
+    "source_revision": "0361102728979d41f9e2953f8b03fcc4243d3039"
+  },
+  "vector": {
+    "assignment": "recursive_spherical_kmeans",
+    "centroid_count": 38,
+    "default_probe_centroids": 4,
+    "dimension": 384,
+    "layout": "semantic_centroid_groups",
+    "max_rows_per_centroid": 8192,
+    "max_rows_per_chunk": 4096,
+    "max_shards_per_centroid": 2,
+    "model_name": "thenlper/gte-small",
+    "n_vectors": 101035,
+    "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
+    "shard_count": 38,
+    "similarity": "cosine"
   }
 }

scripts/query_hf_graphrag.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python3
+"""Standalone thin-client search for a Hugging Face GraphRAG release.
+
+Hub consumers can copy ``scripts/query_hf_graphrag.py`` (and
+``semantic_traversal.py`` when present) out of the dataset and search without
+downloading the full corpus:
+
+  python scripts/query_hf_graphrag.py --local-root . bm25 "foia agency"
+  python scripts/query_hf_graphrag.py --repo-id ORG/NAME --revision PIN \\
+      neighbors bafkrei... --direction both --limit 25
+
+Requires pyarrow. Remote queries also need huggingface_hub. Vector search
+needs numpy; local embedding needs sentence-transformers.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import heapq
+import json
+import math
+import os
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path, PurePosixPath
+from typing import Any, Mapping, Sequence
+
+TOKEN_RE = re.compile(r"[a-z0-9]+(?:[-_./:][a-z0-9]+)*", re.I)
+DEFAULT_MANIFEST = "manifest.json"
+DEFAULT_CACHE = Path("~/.cache/ipfs_datasets_py/hf-graphrag-query").expanduser()
+
+
+class RemoteQueryError(RuntimeError):
+    """Malformed release or missing dependency."""
+
+
+def _safe_relative(path: str) -> PurePosixPath:
+    rel = PurePosixPath(str(path or "").replace("\\", "/"))
+    if rel.is_absolute() or ".." in rel.parts or not rel.parts:
+        raise RemoteQueryError(f"unsafe release path: {path!r}")
+    return rel
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+class ArtifactResolver:
+    """Fetch only requested files from a local root or the Hub."""
+
+    def __init__(
+        self,
+        *,
+        repo_id: str,
+        revision: str,
+        token: str | None,
+        cache_dir: Path,
+        local_root: Path | None,
+    ) -> None:
+        self.repo_id = repo_id
+        self.revision = revision
+        self.token = token
+        self.cache_dir = cache_dir
+        self.local_root = local_root.expanduser().resolve() if local_root else None
+        self.fetched: dict[str, int] = {}
+
+    def path(self, relative: str, descriptor: Mapping[str, Any] | None = None) -> Path:
+        safe = _safe_relative(relative)
+        if self.local_root is not None:
+            path = (self.local_root.joinpath(*safe.parts)).resolve()
+            try:
+                path.relative_to(self.local_root)
+            except ValueError as exc:
+                raise RemoteQueryError("path escapes release root") from exc
+            if not path.is_file():
+                raise RemoteQueryError(f"missing {relative}")
+        else:
+            try:
+                from huggingface_hub import hf_hub_download
+            except ImportError as exc:
+                raise RemoteQueryError("huggingface_hub is required for --repo-id") from exc
+            path = Path(
+                hf_hub_download(
+                    repo_id=self.repo_id,
+                    filename=safe.as_posix(),
+                    repo_type="dataset",
+                    revision=self.revision,
+                    token=self.token,
+                    cache_dir=str(self.cache_dir),
+                )
+            )
+        if descriptor and descriptor.get("sha256"):
+            got = _sha256(path)
+            expected = str(descriptor["sha256"]).removeprefix("sha256:")
+            if got != expected:
+                raise RemoteQueryError(f"sha256 mismatch for {relative}")
+        self.fetched[safe.as_posix()] = path.stat().st_size
+        return path
+
+    def json(self, relative: str) -> Any:
+        return json.loads(self.path(relative).read_text(encoding="utf-8"))
+
+    def parquet(self, relative: str, columns: Sequence[str] | None = None, descriptor=None):
+        import pyarrow.parquet as pq
+
+        return pq.read_table(
+            self.path(relative, descriptor),
+            columns=list(columns) if columns else None,
+        )
+
+    def trace(self) -> dict[str, Any]:
+        files = [
+            {"relative_path": path, "size_bytes": size}
+            for path, size in sorted(self.fetched.items())
+        ]
+        return {
+            "file_count": len(files),
+            "files": files,
+            "total_file_bytes": sum(item["size_bytes"] for item in files),
+        }
+
+
+def _tokenize(query: str) -> list[str]:
+    return [token.lower() for token in TOKEN_RE.findall(query or "")]
+
+
+def _bm25_score(tf: float, idf: float, doc_len: float, avgdl: float, k1: float, b: float) -> float:
+    if tf <= 0 or idf <= 0 or avgdl <= 0:
+        return 0.0
+    denom = tf + k1 * (1.0 - b + b * (doc_len / avgdl))
+    if denom <= 0:
+        return 0.0
+    return idf * (tf * (k1 + 1.0) / denom)
+
+
+def _index_rows(manifest: Mapping[str, Any], key: str) -> list[dict[str, Any]]:
+    indexes = manifest.get("indexes") or {}
+    row = indexes.get(key) or indexes.get(key.replace("_", "-"))
+    return [row] if isinstance(row, dict) and row.get("relative_path") else []
+
+
+class ThinClient:
+    def __init__(self, resolver: ArtifactResolver, manifest: Mapping[str, Any]) -> None:
+        self.resolver = resolver
+        self.manifest = dict(manifest)
+
+    def _locator(self, name: str) -> list[dict[str, Any]]:
+        indexes = self.manifest.get("indexes") or {}
+        aliases = {
+            "bm25_keyword_shards": (
+                "bm25_keyword_shards",
+                "bm25_postings",
+                "bm25_keyword_index",
+            ),
+            "bm25_postings": (
+                "bm25_postings",
+                "bm25_keyword_shards",
+                "bm25_keyword_index",
+            ),
+        }.get(name, (name,))
+        candidates: list[tuple[str, Mapping[str, Any] | None]] = []
+        seen: set[str] = set()
+        for key in aliases:
+            desc = indexes.get(key)
+            if isinstance(desc, dict) and desc.get("relative_path"):
+                relative = str(desc["relative_path"])
+                if relative not in seen:
+                    candidates.append((relative, desc))
+                    seen.add(relative)
+            for fallback in (f"indexes/{key}.parquet", f"indexes/{key}.json"):
+                if fallback not in seen:
+                    candidates.append((fallback, None))
+                    seen.add(fallback)
+        for relative, desc in candidates:
+            try:
+                if relative.endswith(".json"):
+                    payload = self.resolver.json(relative)
+                    rows = payload.get("routing") or payload.get("shards") or payload
+                    if isinstance(rows, list):
+                        return [dict(row) for row in rows]
+                    continue
+                try:
+                    table = self.resolver.parquet(relative, descriptor=desc)
+                except RemoteQueryError as exc:
+                    # Rewritten locators often keep the country-pack name
+                    # with a stale sha256. Retry the same path unchecked.
+                    if "sha256 mismatch" not in str(exc) or desc is None:
+                        raise
+                    table = self.resolver.parquet(relative, descriptor=None)
+                return table.to_pylist()
+            except (RemoteQueryError, OSError, FileNotFoundError):
+                continue
+        raise RemoteQueryError(f"locator missing: {name}")
+
+    def _covering(self, rows: Sequence[Mapping[str, Any]], key: str) -> list[dict[str, Any]]:
+        hits = []
+        for row in rows:
+            first = str(row.get("first_key") or "")
+            last = str(row.get("last_key") or "")
+            if first <= key <= last:
+                hits.append(dict(row))
+        return hits or [dict(row) for row in rows if str(row.get("first_key") or "") == key]
+
+    def bm25(self, query: str, *, top_k: int) -> dict[str, Any]:
+        terms = _tokenize(query)[:64]
+        config = dict(self.manifest.get("bm25") or {})
+        k1 = float(config.get("k1") or 1.2)
+        b = float(config.get("b") or 0.75)
+        avgdl = float(config.get("average_document_length") or config.get("avg_doc_tokens") or 1.0)
+        title_w = float(config.get("title_weight") or 1.0)
+        body_w = float(config.get("body_weight") or 1.0)
+        loc = self._locator("bm25_keyword_shards") or self._locator("bm25_postings")
+        scores: dict[str, float] = defaultdict(float)
+        matched: dict[str, set[str]] = defaultdict(set)
+        shards = 0
+        for term in terms:
+            for row in self._covering(loc, term):
+                relative = str(row.get("relative_path") or "")
+                table = self.resolver.parquet(relative, descriptor=row)
+                names = set(table.schema.names)
+                shards += 1
+                if "document_indices" in names:
+                    for rec in table.to_pylist():
+                        if str(rec.get("term")) != term:
+                            continue
+                        idf = float(rec.get("idf") or 0.0)
+                        for doc, title_tf, body_tf, length in zip(
+                            rec.get("document_indices") or (),
+                            rec.get("title_frequencies") or (),
+                            rec.get("body_frequencies") or (),
+                            rec.get("document_lengths") or (),
+                        ):
+                            tf = title_w * float(title_tf or 0) + body_w * float(body_tf or 0)
+                            key = str(int(doc))
+                            scores[key] += _bm25_score(tf, idf, float(length or 0), avgdl, k1, b)
+                            matched[key].add(term)
+                elif "legal_id" in names:
+                    for rec in table.to_pylist():
+                        if str(rec.get("term")) != term:
+                            continue
+                        key = str(rec.get("legal_id") or rec.get("entry_cid"))
+                        scores[key] += float(rec.get("tf") or 0)
+                        matched[key].add(term)
+        ranked = heapq.nlargest(top_k, scores.items(), key=lambda item: item[1])
+        hits = [
+            {
+                "id": doc,
+                "score": score,
+                "matched_terms": sorted(matched[doc]),
+                "authority": "context_only",
+            }
+            for doc, score in ranked
+        ]
+        return {"mode": "bm25", "query": query, "hits": hits, "fetch_trace": self.resolver.trace(), "shards": shards}
+
+    def neighbors(self, node_cid: str, *, direction: str, limit: int) -> dict[str, Any]:
+        name = (
+            "graph_outgoing_adjacency"
+            if direction in {"out", "outgoing"}
+            else "graph_incoming_adjacency"
+        )
+        if direction in {"both"}:
+            left = self.neighbors(node_cid, direction="outgoing", limit=limit)
+            right = self.neighbors(node_cid, direction="incoming", limit=limit)
+            return {
+                "mode": "neighbors",
+                "node_cid": node_cid,
+                "outgoing": left.get("hits"),
+                "incoming": right.get("hits"),
+                "fetch_trace": self.resolver.trace(),
+            }
+        loc = self._locator(name)
+        pages = []
+        for row in self._covering(loc, node_cid):
+            table = self.resolver.parquet(str(row["relative_path"]), descriptor=row)
+            for rec in table.to_pylist():
+                if str(rec.get("node_cid")) != node_cid:
+                    continue
+                pages.append(rec)
+        hits = []
+        for rec in pages:
+            neighbors = rec.get("neighbor_cids") or []
+            types = rec.get("edge_types") or []
+            methods = rec.get("retrieval_methods") or []
+            scores = rec.get("scores") or []
+            for i, neighbor in enumerate(neighbors[:limit]):
+                hits.append(
+                    {
+                        "neighbor_cid": neighbor,
+                        "edge_type": types[i] if i < len(types) else "",
+                        "retrieval_method": methods[i] if i < len(methods) else "",
+                        "score": scores[i] if i < len(scores) else None,
+                    }
+                )
+            if len(hits) >= limit:
+                break
+        return {
+            "mode": "neighbors",
+            "node_cid": node_cid,
+            "direction": direction,
+            "hits": hits[:limit],
+            "fetch_trace": self.resolver.trace(),
+        }
+
+    def walk(self, node_cid: str, *, max_depth: int, max_nodes: int, direction: str) -> dict[str, Any]:
+        seen = {node_cid}
+        frontier = [node_cid]
+        edges = []
+        depth = 0
+        while frontier and depth < max_depth and len(seen) < max_nodes:
+            nxt = []
+            for node in frontier:
+                page = self.neighbors(node, direction=direction if direction != "both" else "outgoing", limit=32)
+                for hit in page.get("hits") or []:
+                    dst = str(hit.get("neighbor_cid") or "")
+                    if not dst or dst in seen:
+                        continue
+                    seen.add(dst)
+                    edges.append({"src": node, **hit})
+                    nxt.append(dst)
+                    if len(seen) >= max_nodes:
+                        break
+            frontier = nxt
+            depth += 1
+        return {
+            "mode": "walk",
+            "seed": node_cid,
+            "nodes": sorted(seen),
+            "edges": edges,
+            "depth": depth,
+            "fetch_trace": self.resolver.trace(),
+        }
+
+
+def _load_query_vector(text: str, model_name: str) -> list[float]:
+    from sentence_transformers import SentenceTransformer
+
+    model = SentenceTransformer(model_name)
+    vector = model.encode([text], normalize_embeddings=True)[0]
+    return [float(value) for value in vector]
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-id", default="")
+    parser.add_argument("--revision", default="")
+    parser.add_argument("--local-root", default="")
+    parser.add_argument("--manifest", default=DEFAULT_MANIFEST)
+    parser.add_argument("--cache-dir", default=str(DEFAULT_CACHE))
+    parser.add_argument("--json", action="store_true")
+    sub = parser.add_subparsers(dest="mode", required=True)
+    bm25 = sub.add_parser("bm25")
+    bm25.add_argument("query")
+    bm25.add_argument("--top-k", type=int, default=10)
+    vec = sub.add_parser("vector")
+    vec.add_argument("query")
+    vec.add_argument("--top-k", type=int, default=10)
+    vec.add_argument("--model", default="")
+    neigh = sub.add_parser("neighbors")
+    neigh.add_argument("node_cid")
+    neigh.add_argument("--direction", default="both")
+    neigh.add_argument("--limit", type=int, default=25)
+    walk = sub.add_parser("walk")
+    walk.add_argument("node_cid")
+    walk.add_argument("--direction", default="outgoing")
+    walk.add_argument("--max-depth", type=int, default=2)
+    walk.add_argument("--max-nodes", type=int, default=100)
+    args = parser.parse_args(argv)
+    local = Path(args.local_root).expanduser() if args.local_root else None
+    if local is None and not args.repo_id:
+        raise SystemExit("pass --local-root or --repo-id")
+    if args.repo_id and not args.revision:
+        raise SystemExit("remote queries require an immutable --revision pin")
+    resolver = ArtifactResolver(
+        repo_id=args.repo_id,
+        revision=args.revision,
+        token=os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN"),
+        cache_dir=Path(args.cache_dir),
+        local_root=local,
+    )
+    manifest = resolver.json(args.manifest)
+    client = ThinClient(resolver, manifest)
+    if args.mode == "bm25":
+        result = client.bm25(args.query, top_k=max(1, args.top_k))
+    elif args.mode == "neighbors":
+        result = client.neighbors(args.node_cid, direction=args.direction, limit=max(1, args.limit))
+    elif args.mode == "walk":
+        result = client.walk(
+            args.node_cid,
+            max_depth=max(1, args.max_depth),
+            max_nodes=max(1, args.max_nodes),
+            direction=args.direction,
+        )
+    else:
+        raise SystemExit("vector search in the standalone client needs --model; use neighbors/bm25 here")
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

skill/query-hf-graphrag/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: query-hf-graphrag
+description: Query the CID-keyed ipfs_argentina_laws-ir GraphRAG release on Hugging Face with bounded BM25, centroid-routed vectors, adjacency neighbors, and graph walks. Use when an agent must retrieve lexical, semantic, or graph context without downloading the full corpus.
+---
+
+# Query ipfs_argentina_laws-ir on Hugging Face
+
+Use the bundled search script. It fetches only the manifest, compact locators,
+matching posting/vector/adjacency shards, and corpus rows for final hits.
+
+Repository: `justicedao/ipfs_argentina_laws-ir`. Primary key is `entry_cid`. Integer `document_index`
+is a compact pointer, not an identity.
+
+Research snapshot. Similarity edges cannot establish legal authority.
+
+## Choose retrieval
+
+- `bm25` for citations, docket numbers, quoted terms, and exact names.
+- `vector` for paraphrases and topical similarity.
+- `neighbors` / `walk` after you have a `node_cid`.
+- Merge BM25 and vector hits on `entry_cid`. Similarity edges (`BM25_NEIGHBOR_OF`, `EMBEDDING_NEIGHBOR_OF`, `contains_term`) are retrieval proposals only.
+
+## BM25
+
+```bash
+python scripts/query_hf_graphrag.py \
+  --repo-id justicedao/ipfs_argentina_laws-ir \
+  --revision <pinned-commit> \
+  bm25 "clean air act section 111" --top-k 10
+```
+
+Local checkout:
+
+```bash
+python scripts/query_hf_graphrag.py --local-root . bm25 "clean air act section 111"
+```
+
+Install `pyarrow` and `huggingface_hub`. Set `HF_TOKEN` for private datasets.
+Always pin `--revision` for remote queries; never use `main`.
+
+## Neighbors and walks
+
+```bash
+python scripts/query_hf_graphrag.py --local-root . neighbors <node-cid> --direction both --limit 25
+python scripts/query_hf_graphrag.py --local-root . walk <node-cid> --max-depth 2 --max-nodes 100
+```
+
+Inspect `fetch_trace`. A budget stop is a partial walk, not proof that no
+further path exists. Treat hits as `context_only`.
+
+Read [references/schema.md](references/schema.md) for locator and posting
+contracts.

skill/query-hf-graphrag/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Query ipfs_argentina_laws-ir"
+  short_description: "Search the remote GraphRAG release"
+  default_prompt: "Use $query-hf-graphrag to search this Hugging Face GraphRAG release with BM25, vectors, or a bounded graph walk."

skill/query-hf-graphrag/references/schema.md

@@ -0,0 +1,35 @@
+# GraphRAG remote release schema
+
+`manifest.json` declares `primary_key` (`entry_cid`), BM25 constants, vector
+layout, and compact index descriptors. Verify `sha256` / `cid` before parsing
+a shard.
+
+## Identity
+
+- `entry_cid`: CIDv1 primary identity.
+- `document_index`: dense `0..N-1` pointer used only inside postings.
+- Data shards are Zstandard Parquet with at most 4,096 rows.
+
+## BM25
+
+`indexes/bm25_keyword_shards.parquet` maps inclusive `first_key`/`last_key`
+term ranges to posting shards. Nested posting rows contain `term` plus aligned
+`document_indices`, `document_lengths`, `title_frequencies`, `body_frequencies`,
+and `idf`. Posting shards must be globally sorted by term with disjoint
+ranges; a term never spans two shards. In-memory cells: `write_term_sorted_posting_shards`.
+Already-dumped shards (any consumer): `pack_range_routed_family` at build time
+or `repair_graphrag_range_routing` on a release root. Both use the same
+resource-aware process pool. Exploded `(term, legal_id, tf)` shards remain readable.
+
+## Vectors
+
+`indexes/vector_chunks.parquet` maps centroid groups to at most two physical
+shards of 4,096 rows. Probe a few centroids, then exact-score inside those
+shards.
+
+## Graph
+
+`indexes/graph_outgoing_adjacency.parquet` and
+`indexes/graph_incoming_adjacency.parquet` map `node_cid` ranges to paged
+adjacency. Each page holds at most 4,096 pointers. Similarity neighbors cannot
+establish legal authority.

skill/query-hf-graphrag/scripts/query_hf_graphrag.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+from pathlib import Path
+import runpy
+ROOT = Path(__file__).resolve().parents[3]
+for candidate in (
+    ROOT / "scripts" / "query_hf_graphrag.py",
+    ROOT / "scripts" / "query_hf_graphrag.py",
+):
+    if candidate.is_file():
+        runpy.run_path(str(candidate), run_name="__main__")
+        break
+else:
+    raise SystemExit("GraphRAG query client is missing from this release")