Add files using upload-large-folder tool

data/bm25/documents/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b30e2aa8a3ab860508a02a9e26f23778712c21ae9d2de137ee2ce3db1d2f08eb
-size 233099
+oid sha256:d345ec5581397c74a89b1ed1048f474287f1b5129367c9b638003a9c3484d603
+size 264694

data/bm25/documents/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:18fcb3b9f0616a5ea391d4d683752acd7e47cec1b25c64f5caefafd3c7a41488
-size 38164
+oid sha256:1c34ab9ba4967e07d922a3e1dc40d2ea8ccbc6c63f0ca933ed6c55ad823f40fe
+size 60550

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d4a96bc69002b19160159aa1b197835fc369919ddea7c422ff86ec113d28fd0d
-size 1072923
+oid sha256:de235829a76e4a7cce70a64b8012a2429df5dd491900693d1539f330d5b3011a
+size 1169368

data/corpus/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:09a34796339315d95c330c936e740a966f2b142baa9c8ef7ca271f38d731d137
-size 123868
+oid sha256:71264c61710b4ba78aa5d43d811413fced90735af5d5ea2adea21c8370067706
+size 217659

indexes/bm25_document_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4af93d863bff15f1b8b62c9261db1bf902eaff01e30e6bb520b9622c8b23ccd9
-size 9036
+oid sha256:33e121e9df28a84a6a0e5dc53706b562b9515d82ec124e1148e1e83abdbbee3c
+size 5187

indexes/bm25_keyword_shards.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9ff35314e5060f525cc12483d3e37453be62cc2fc915261291822a8affb411da
-size 10128
+oid sha256:128ffd153fdd4d18419f3988bfafe8bfa9c9a3717cb10841bce38d927d8cee86
+size 4370

indexes/corpus_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6fc266aac245555e23b41c531cd932b6456c07029ca632cbf06fa2eaba2f18eb
-size 8952
+oid sha256:ed089ae0b2c3be7a0550f79bef41ef887b54546fa8f2bb4bfcb4bfba429e880e
+size 5102

indexes/graph_edge_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dfc60ea17fa6a7a170fea4a873bcfb811af48644997c13fc5c9525551c6546ff
-size 10526
+oid sha256:c1874e3829b7ca4296afb272a8f6401d7261872268c204e07e4b462cf66a80bc
+size 7022

indexes/graph_incoming_adjacency.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:83e21c0296e8e5f2909ee77fedbb9a3b9975d31a0018899f970446ac3950af39
-size 11960
+oid sha256:33e2d36333a87021f8475d0ec1975e77b0a7977a9bf9f42000c97245ec54808b
+size 5044

indexes/graph_node_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:01f85730078e34c7b3e59599803e47a0215bf658b27442050fe25ad3e2cd0cea
-size 8987
+oid sha256:fa861de772ecc445a5e0f5578a24b79e0b10af29c66472428f892111f17ed9db
+size 5154

indexes/graph_outgoing_adjacency.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6ca782503ba7ff47dacef44cc95116d3c76beefe29576164d6a8f60df1d659a1
-size 12177
+oid sha256:8d09fe534aa0365aa91a93760f0bdc205e39b7bdc0f6a69f851b38ba5acd84bf
+size 5288

indexes/vector_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:324977ab14fdf3e64e29386f8ce041fbfe55304f3419b40b5debf4641349240f
-size 22921
+oid sha256:3ceeb2197003a10f74f117c1871e044d6f89be10d1bd4fc8c33cc0176f3d4e38
+size 5114

manifest.json

@@ -1,62 +1,81 @@
 {
-  "schema_version": "country-laws-ir-graphrag/v1",
-  "layout_family": "skillcenter-huggingface-release/v3",
-  "packager_version": "0.3.0",
-  "primary_key": "entry_cid",
-  "dataset_id": "endomorphosis/ipfs_saudiarabia_laws",
-  "dataset_repo_id": "justicedao/ipfs_saudiarabia_laws_ir",
-  "dataset_revision": "47bbf142ade8",
-  "country": {
-    "slug": "saudiarabia",
-    "repo": "endomorphosis/ipfs_saudiarabia_laws",
-    "name": "Saudi Arabia",
-    "indexable": true,
-    "skip_reason": null,
-    "local_source_dir": "/workspace/country-laws-ir/cache/saudi_filtered_47bbf142",
-    "source_revision": "47bbf142ade8"
-  },
-  "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
   "bm25": {
-    "k1": 1.2,
+    "average_document_length": 5.600771869639794,
     "b": 0.75,
-    "title_weight": 5.0,
     "body_weight": 1.0,
-    "average_document_length": 5.600771869639794,
-    "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"
+  },
+  "canonical_fields": [
+    "entry_cid",
+    "law_cid",
+    "record_type",
+    "jurisdiction",
+    "language",
+    "instrument_id",
+    "instrument_title",
+    "article_number",
+    "article_title",
+    "title",
+    "body",
+    "source_url",
+    "snapshot_date",
+    "coverage",
+    "license",
+    "collector",
+    "source_dataset",
+    "source_revision"
+  ],
+  "cid": {
+    "codec": "raw",
+    "hash": "sha2-256",
+    "multibase": "base32",
+    "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')"
+  },
+  "country": {
+    "indexable": true,
+    "local_source_dir": "/workspace/country-laws-ir/cache/saudi_filtered_47bbf142",
+    "name": "Saudi Arabia",
+    "repo": "endomorphosis/ipfs_saudiarabia_laws",
+    "skip_reason": null,
+    "slug": "saudiarabia",
+    "source_revision": "47bbf142ade8"
   },
   "counts": {
     "bm25_document_chunks": 2,
     "bm25_documents": 4664,
     "bm25_keyword_shards": 1,
     "bm25_posting_rows": 1498,
+    "bm25_posting_shards": 1,
     "bm25_postings": 10560,
     "bm25_terms": 1498,
     "corpus_chunks": 2,
     "corpus_rows": 4664,
+    "corpus_shards": 2,
     "graph_edge_chunks": 12,
     "graph_edges": 45185,
     "graph_incoming_adjacency_edges": 45185,
     "graph_incoming_adjacency_rows": 2445,
     "graph_incoming_adjacency_shards": 1,
     "graph_node_chunks": 2,
+    "graph_node_shards": 2,
     "graph_nodes": 5353,
     "graph_outgoing_adjacency_edges": 45185,
     "graph_outgoing_adjacency_rows": 4664,
     "graph_outgoing_adjacency_shards": 2,
-    "vector_chunks": 2,
-    "vector_rows": 4664,
+    "n_articles": 4664,
     "n_laws": 0,
-    "n_articles": 4664
-  },
-  "parquet": {
-    "compression": "zstd",
-    "compression_level": 6,
-    "max_rows_per_file": 4096,
-    "row_group_size": 4096
+    "vector_chunks": 2,
+    "vector_rows": 4664
   },
+  "dataset_id": "endomorphosis/ipfs_saudiarabia_laws",
+  "dataset_repo_id": "justicedao/ipfs_saudiarabia_laws_ir",
+  "dataset_revision": "47bbf142ade8",
+  "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
   "graph": {
     "adjacency_pointers_per_row": 4096,
     "adjacency_pointers_per_shard": 8192,
@@ -64,8 +83,6 @@
       "incoming",
       "outgoing"
     ],
-    "max_remote_walk_depth": 8,
-    "ordering": "score_desc_nulls_last",
     "edge_types": [
       "ARTICLE_OF",
       "BM25_NEIGHBOR_OF",
@@ -75,202 +92,288 @@
       "HAS_SOURCE",
       "HAS_STATUS",
       "IDENTIFIED_BY"
-    ]
+    ],
+    "max_remote_walk_depth": 8,
+    "ordering": "score_desc_nulls_last"
   },
-  "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": 2,
-    "centroid_count": 2,
-    "shard_count": 2,
-    "n_vectors": 4664,
-    "status": "embedded"
+  "indexes": {
+    "bm25_document_chunks": {
+      "cid": "bafkreick7e6ymo77cxy3rnrmsjq5wg7zalvp6apdbzv3kifzmiwiwi6m3e",
+      "content_cid": "bafkreibt4eq6txzivbfguds5yu3qnnlcxfiv3axmcjhbcshb5a5l3o7ohq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_document_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "33e121e9df28a84a6a0e5dc53706b562b9515d82ec124e1148e1e83abdbbee3c",
+      "size_bytes": 5187
+    },
+    "bm25_documents": {
+      "content_cid": "bafkreibt4eq6txzivbfguds5yu3qnnlcxfiv3axmcjhbcshb5a5l3o7ohq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_document_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "33e121e9df28a84a6a0e5dc53706b562b9515d82ec124e1148e1e83abdbbee3c",
+      "size_bytes": 5187
+    },
+    "bm25_keyword_index": {
+      "content_cid": "bafkreiasr76rkp65jumedhzzrc7272f7vhe2g4l4weeedphdrwjh3dhoqy",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 1,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "128ffd153fdd4d18419f3988bfafe8bfa9c9a3717cb10841bce38d927d8cee86",
+      "size_bytes": 4370
+    },
+    "bm25_keyword_shards": {
+      "cid": "bafkreie76njrjzigb5jfzqjeqpj6g5ctxzrmyl6jcutbfemcfkfp7nar3i",
+      "content_cid": "bafkreiasr76rkp65jumedhzzrc7272f7vhe2g4l4weeedphdrwjh3dhoqy",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 1,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "128ffd153fdd4d18419f3988bfafe8bfa9c9a3717cb10841bce38d927d8cee86",
+      "size_bytes": 4370
+    },
+    "bm25_postings": {
+      "content_cid": "bafkreiasr76rkp65jumedhzzrc7272f7vhe2g4l4weeedphdrwjh3dhoqy",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/bm25_keyword_shards.parquet",
+      "row_count": 1,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "128ffd153fdd4d18419f3988bfafe8bfa9c9a3717cb10841bce38d927d8cee86",
+      "size_bytes": 4370
+    },
+    "corpus": {
+      "content_cid": "bafkreihnbcnobmwdxz5akuhxtpxud34ipnkfi35i6k5ux7fux65efhuiby",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/corpus_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "ed089ae0b2c3be7a0550f79bef41ef887b54546fa8f2bb4bfcb4bfba429e880e",
+      "size_bytes": 5102
+    },
+    "corpus_chunks": {
+      "cid": "bafkreidpyjtkvqsfkvpchna4kmonsmvwivwaoau4uyzmx4dpulvlulyy5m",
+      "content_cid": "bafkreihnbcnobmwdxz5akuhxtpxud34ipnkfi35i6k5ux7fux65efhuiby",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/corpus_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "ed089ae0b2c3be7a0550f79bef41ef887b54546fa8f2bb4bfcb4bfba429e880e",
+      "size_bytes": 5102
+    },
+    "graph_edge_chunks": {
+      "cid": "bafkreig7yyhkc75gu6qxb7vevbz3z64bdl2imrezpqj7yxevevkryzkg74",
+      "content_cid": "bafkreigbq5hdqknxzjbjnl5sokupmqa5ojqyoitiyicoa7sliywpm2uaxq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_edge_chunks.parquet",
+      "row_count": 12,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "c1874e3829b7ca4296afb272a8f6401d7261872268c204e07e4b462cf66a80bc",
+      "size_bytes": 7022
+    },
+    "graph_edges": {
+      "content_cid": "bafkreigbq5hdqknxzjbjnl5sokupmqa5ojqyoitiyicoa7sliywpm2uaxq",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_edge_chunks.parquet",
+      "row_count": 12,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "c1874e3829b7ca4296afb272a8f6401d7261872268c204e07e4b462cf66a80bc",
+      "size_bytes": 7022
+    },
+    "graph_incoming_adjacency": {
+      "cid": "bafkreied4ioaffxi4xzjbhxhp7w3xgr3tf25ggqadcez7fyei2wdsufphe",
+      "content_cid": "bafkreibt4ljwgm5ioaq7qr25b3azoxtxwctzo6u37h2caagjojc6yvearm",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_incoming_adjacency.parquet",
+      "row_count": 1,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "33e2d36333a87021f8475d0ec1975e77b0a7977a9bf9f42000c97245ec54808b",
+      "size_bytes": 5044
+    },
+    "graph_node_chunks": {
+      "cid": "bafkreiab7bltab4ogtd3hzmvtgad4r5aefn7mwfsorbakd7cllj6ftim5i",
+      "content_cid": "bafkreih2qyo6o4xmyrc2lyhvk6fcjn46bmik6kogmrzefd4jeei7c7wz3m",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_node_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "fa861de772ecc445a5e0f5578a24b79e0b10af29c66472428f892111f17ed9db",
+      "size_bytes": 5154
+    },
+    "graph_nodes": {
+      "content_cid": "bafkreih2qyo6o4xmyrc2lyhvk6fcjn46bmik6kogmrzefd4jeei7c7wz3m",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_node_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "fa861de772ecc445a5e0f5578a24b79e0b10af29c66472428f892111f17ed9db",
+      "size_bytes": 5154
+    },
+    "graph_outgoing_adjacency": {
+      "cid": "bafkreidmu6bfao5h75d5vtxujtevcfwty5v657rjk5qwjvvi6yg7dvszue",
+      "content_cid": "bafkreienbh7fgsvagznksgutoyhqxxbaly43ppoa62tj7bi3hc5fvtmex4",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/graph_outgoing_adjacency.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "8d09fe534aa0365aa91a93760f0bdc205e39b7bdc0f6a69f851b38ba5acd84bf",
+      "size_bytes": 5288
+    },
+    "vector_chunks": {
+      "cid": "bafkreibsjf32wfh56pte4kjyn6goaqp37zktatzudg2awxpl6rsbgsjeb4",
+      "content_cid": "bafkreib452zbs4aduehxj4ixygdr4bcnn6e34egrxvh4rqz4yalw6pkoha",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/vector_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "3ceeb2197003a10f74f117c1871e044d6f89be10d1bd4fc8c33cc0176f3d4e38",
+      "size_bytes": 5114
+    },
+    "vectors": {
+      "content_cid": "bafkreib452zbs4aduehxj4ixygdr4bcnn6e34egrxvh4rqz4yalw6pkoha",
+      "family": "routing_index",
+      "media_type": "application/vnd.apache.parquet",
+      "relative_path": "indexes/vector_chunks.parquet",
+      "row_count": 2,
+      "schema_id": "hf-graphrag-compact-index/v1",
+      "sha256": "3ceeb2197003a10f74f117c1871e044d6f89be10d1bd4fc8c33cc0176f3d4e38",
+      "size_bytes": 5114
+    }
   },
-  "canonical_fields": [
-    "entry_cid",
-    "law_cid",
-    "record_type",
-    "jurisdiction",
-    "language",
-    "instrument_id",
-    "instrument_title",
-    "article_number",
-    "article_title",
-    "title",
-    "body",
-    "source_url",
-    "snapshot_date",
-    "coverage",
-    "license",
-    "collector",
-    "source_dataset",
-    "source_revision"
-  ],
   "input_sha256": {
-    "laws.parquet": "71842e905fd18d1b13f19d5dc02288a5909765c377b06b86b145862702ade3f8",
-    "articles.parquet": "c57d41b22c1d0210dc7d25bd3e0da8f5c16a3f50c0935896ed512db3b979a0a2"
+    "articles.parquet": "c57d41b22c1d0210dc7d25bd3e0da8f5c16a3f50c0935896ed512db3b979a0a2",
+    "laws.parquet": "71842e905fd18d1b13f19d5dc02288a5909765c377b06b86b145862702ade3f8"
   },
+  "layout_family": "skillcenter-huggingface-release/v3",
   "model_id": "thenlper/gte-small",
-  "cid": {
-    "codec": "raw",
-    "hash": "sha2-256",
-    "multibase": "base32",
-    "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')"
-  },
   "normalization": {
-    "source_dataset": "endomorphosis/ipfs_saudiarabia_laws",
-    "source_revision": "47bbf142ade8",
-    "laws_sha256": "71842e905fd18d1b13f19d5dc02288a5909765c377b06b86b145862702ade3f8",
-    "articles_sha256": "c57d41b22c1d0210dc7d25bd3e0da8f5c16a3f50c0935896ed512db3b979a0a2",
-    "n_laws_in": 623,
-    "n_articles_in": 4664,
-    "unit": "article",
     "article_law_coverage": 7.486356340288925,
-    "sparse_article_fallback": false,
+    "articles_sha256": "c57d41b22c1d0210dc7d25bd3e0da8f5c16a3f50c0935896ed512db3b979a0a2",
+    "drop_samples": {
+      "duplicate_cid": [],
+      "empty_body": [],
+      "missing_instrument": []
+    },
     "drops": {
-      "empty_body": 0,
-      "missing_instrument": 0,
       "duplicate_cid": 0,
-      "duplicate_source_kept_first": 0
+      "duplicate_source_kept_first": 0,
+      "empty_body": 0,
+      "missing_instrument": 0
     },
-    "drop_samples": {
-      "empty_body": [],
-      "missing_instrument": [],
-      "duplicate_cid": []
+    "jurisdiction_breakdown": {
+      "SA": 4664
     },
     "language_breakdown": {
       "ar": 4400,
       "en": 264
     },
+    "laws_sha256": "71842e905fd18d1b13f19d5dc02288a5909765c377b06b86b145862702ade3f8",
+    "n_articles_in": 4664,
+    "n_before_dedupe": 4664,
+    "n_dropped_total": 0,
+    "n_laws_in": 623,
+    "n_out": 4664,
+    "never_invented_legal_text": true,
     "quality_flags": {
-      "articles_table_empty": false,
-      "sparse_article_fallback": false,
-      "article_law_coverage": 7.486356340288925,
       "all_source_article_counts_zero": false,
       "article_extraction_status_counts": {
-        "ok": 232,
-        "missing": 391
+        "missing": 391,
+        "ok": 232
       },
+      "article_law_coverage": 7.486356340288925,
+      "articles_table_empty": false,
+      "duplicate_cids_dropped": 0,
+      "eli_present": false,
+      "empty_bodies_dropped": 0,
       "missing_date": false,
       "missing_date_issued": false,
-      "eli_present": false,
       "never_invented_legal_text": true,
-      "empty_bodies_dropped": 0,
-      "duplicate_cids_dropped": 0
+      "sparse_article_fallback": false
+    },
+    "record_type_breakdown": {
+      "article": 4664
     },
     "schema_surprises": [
       "laws.article_count dtype=int64",
       "laws.eli non-null=0/623",
       "laws.language values=['ar', 'en']"
     ],
-    "n_out": 4664,
-    "never_invented_legal_text": true,
-    "n_before_dedupe": 4664,
-    "n_dropped_total": 0,
-    "record_type_breakdown": {
-      "article": 4664
-    },
-    "jurisdiction_breakdown": {
-      "SA": 4664
-    },
     "snapshot_dates": [
       "2026-09-04"
-    ]
+    ],
+    "source_dataset": "endomorphosis/ipfs_saudiarabia_laws",
+    "source_revision": "47bbf142ade8",
+    "sparse_article_fallback": false,
+    "unit": "article"
+  },
+  "packager_version": "0.3.0",
+  "parquet": {
+    "compression": "zstd",
+    "compression_level": 6,
+    "max_rows_per_file": 4096,
+    "row_group_size": 4096
   },
+  "primary_key": "entry_cid",
   "schema_mapping": {
-    "laws": {
-      "id": "instrument_id",
-      "title": "instrument_title",
-      "text": "body",
-      "article_count_dtype_source": "int64"
-    },
     "articles": {
       "id": "source_id / article identity",
       "law_id": "instrument_id",
-      "title": "article_title",
-      "text": "body"
+      "text": "body",
+      "title": "article_title"
     },
-    "unit_policy": "prefer articles; fall back to law-level when articles empty",
-    "required_law_columns": [
+    "fail_closed": true,
+    "laws": {
+      "article_count_dtype_source": "int64",
+      "id": "instrument_id",
+      "text": "body",
+      "title": "instrument_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. Layout matches SkillCenter HF release / publicus-ir family.",
+    "required_article_columns": [
       "id",
+      "law_id",
       "title",
       "text"
     ],
-    "required_article_columns": [
+    "required_law_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. Layout matches SkillCenter HF release / publicus-ir family."
-  },
-  "indexes": {
-    "bm25_document_chunks": {
-      "cid": "bafkreick7e6ymo77cxy3rnrmsjq5wg7zalvp6apdbzv3kifzmiwiwi6m3e",
-      "sha256": "4af93d863bff15f1b8b62c9261db1bf902eaff01e30e6bb520b9622c8b23ccd9",
-      "size_bytes": 9036,
-      "relative_path": "indexes/bm25_document_chunks.parquet"
-    },
-    "bm25_keyword_shards": {
-      "cid": "bafkreie76njrjzigb5jfzqjeqpj6g5ctxzrmyl6jcutbfemcfkfp7nar3i",
-      "sha256": "9ff35314e5060f525cc12483d3e37453be62cc2fc915261291822a8affb411da",
-      "size_bytes": 10128,
-      "relative_path": "indexes/bm25_keyword_shards.parquet"
-    },
-    "corpus_chunks": {
-      "cid": "bafkreidpyjtkvqsfkvpchna4kmonsmvwivwaoau4uyzmx4dpulvlulyy5m",
-      "sha256": "6fc266aac245555e23b41c531cd932b6456c07029ca632cbf06fa2eaba2f18eb",
-      "size_bytes": 8952,
-      "relative_path": "indexes/corpus_chunks.parquet"
-    },
-    "graph_edge_chunks": {
-      "cid": "bafkreig7yyhkc75gu6qxb7vevbz3z64bdl2imrezpqj7yxevevkryzkg74",
-      "sha256": "dfc60ea17fa6a7a170fea4a873bcfb811af48644997c13fc5c9525551c6546ff",
-      "size_bytes": 10526,
-      "relative_path": "indexes/graph_edge_chunks.parquet"
-    },
-    "graph_incoming_adjacency": {
-      "cid": "bafkreied4ioaffxi4xzjbhxhp7w3xgr3tf25ggqadcez7fyei2wdsufphe",
-      "sha256": "83e21c0296e8e5f2909ee77fedbb9a3b9975d31a0018899f970446ac3950af39",
-      "size_bytes": 11960,
-      "relative_path": "indexes/graph_incoming_adjacency.parquet"
-    },
-    "graph_node_chunks": {
-      "cid": "bafkreiab7bltab4ogtd3hzmvtgad4r5aefn7mwfsorbakd7cllj6ftim5i",
-      "sha256": "01f85730078e34c7b3e59599803e47a0215bf658b27442050fe25ad3e2cd0cea",
-      "size_bytes": 8987,
-      "relative_path": "indexes/graph_node_chunks.parquet"
-    },
-    "graph_outgoing_adjacency": {
-      "cid": "bafkreidmu6bfao5h75d5vtxujtevcfwty5v657rjk5qwjvvi6yg7dvszue",
-      "sha256": "6ca782503ba7ff47dacef44cc95116d3c76beefe29576164d6a8f60df1d659a1",
-      "size_bytes": 12177,
-      "relative_path": "indexes/graph_outgoing_adjacency.parquet"
-    },
-    "vector_chunks": {
-      "cid": "bafkreibsjf32wfh56pte4kjyn6goaqp37zktatzudg2awxpl6rsbgsjeb4",
-      "sha256": "324977ab14fdf3e64e29386f8ce041fbfe55304f3419b40b5debf4641349240f",
-      "size_bytes": 22921,
-      "relative_path": "indexes/vector_chunks.parquet"
-    }
+    "unit_policy": "prefer articles; fall back to law-level when articles empty"
   },
+  "schema_version": "country-laws-ir-graphrag/v1",
   "source": {
-    "source_dataset": "endomorphosis/ipfs_saudiarabia_laws",
-    "source_revision": "47bbf142ade8",
-    "laws_path": "/workspace/country-laws-ir/cache/saudi_filtered_47bbf142/data/laws.parquet",
+    "article_count_dtype": "int64",
+    "articles_columns": [
+      "law_id",
+      "id",
+      "title",
+      "text",
+      "source_url",
+      "document_number",
+      "article_number",
+      "record_type",
+      "metadata_json"
+    ],
     "articles_path": "/workspace/country-laws-ir/cache/saudi_filtered_47bbf142/data/articles.parquet",
-    "laws_sha256": "71842e905fd18d1b13f19d5dc02288a5909765c377b06b86b145862702ade3f8",
     "articles_sha256": "c57d41b22c1d0210dc7d25bd3e0da8f5c16a3f50c0935896ed512db3b979a0a2",
-    "n_laws_source": 623,
-    "n_articles_source": 4664,
     "laws_columns": [
       "id",
       "title",
@@ -292,34 +395,44 @@
       "json_path",
       "metadata_json"
     ],
-    "articles_columns": [
-      "law_id",
-      "id",
-      "title",
-      "text",
-      "source_url",
-      "document_number",
-      "article_number",
-      "record_type",
-      "metadata_json"
-    ],
-    "article_count_dtype": "int64",
-    "schema_surprises": [
-      "laws.article_count dtype=int64",
-      "laws.eli non-null=0/623",
-      "laws.language values=['ar', 'en']"
-    ],
+    "laws_path": "/workspace/country-laws-ir/cache/saudi_filtered_47bbf142/data/laws.parquet",
+    "laws_sha256": "71842e905fd18d1b13f19d5dc02288a5909765c377b06b86b145862702ade3f8",
     "local_source_dir": "/workspace/country-laws-ir/cache/saudi_filtered_47bbf142",
+    "n_articles_source": 4664,
+    "n_laws_source": 623,
     "pack_meta": {
-      "slug": "saudiarabia",
+      "filter_reason": "soft article filter: drop form-UI (\u0631\u0645\u0632 \u0627\u0644\u062a\u062d\u0642\u0642 / \u062d\u0642\u0644 \u0627\u0644\u0645\u0627\u062f\u0629 \u0645\u0637\u0644\u0648\u0628) + empty title-only stubs (text len<30)",
+      "filtered": true,
+      "indexable": true,
       "name": "Saudi Arabia",
+      "publish_revision_note": "98e4e98014b9 (local PUBLISH_STATUS); Hub tip HEAD 47bbf142ade8",
       "repo": "endomorphosis/ipfs_saudiarabia_laws",
+      "slug": "saudiarabia",
       "source_dataset": "endomorphosis/ipfs_saudiarabia_laws",
-      "source_revision": "47bbf142ade8",
-      "publish_revision_note": "98e4e98014b9 (local PUBLISH_STATUS); Hub tip HEAD 47bbf142ade8",
-      "filtered": true,
-      "filter_reason": "soft article filter: drop form-UI (رمز التحقق / حقل المادة مطلوب) + empty title-only stubs (text len<30)",
-      "indexable": true
-    }
+      "source_revision": "47bbf142ade8"
+    },
+    "schema_surprises": [
+      "laws.article_count dtype=int64",
+      "laws.eli non-null=0/623",
+      "laws.language values=['ar', 'en']"
+    ],
+    "source_dataset": "endomorphosis/ipfs_saudiarabia_laws",
+    "source_revision": "47bbf142ade8"
+  },
+  "vector": {
+    "assignment": "recursive_spherical_kmeans",
+    "centroid_count": 2,
+    "default_probe_centroids": 2,
+    "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": 4664,
+    "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
+    "shard_count": 2,
+    "similarity": "cosine",
+    "status": "embedded"
   }
 }

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_saudiarabia_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_saudiarabia_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_saudiarabia_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_saudiarabia_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_saudiarabia_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")