| |
| """ |
| build_bundle.py — gather EVERYTHING the RAG is made of into one place: rag_bundle/ |
| |
| - all_chunks.jsonl : every text chunk from every collection, unified schema, |
| deduped by chunk_id, tagged with `collection` (embeddings stripped -> portable). |
| - embedded/ : symlinks to the real *_embedded.jsonl (vectors, no copy). |
| - source_chunks/ : symlinks to each collection's source chunks.jsonl. |
| - raw/ : symlinks to the parsed-markdown dirs (marine_parsed, etc.). |
| - sidecars/ : notebook code sidecar + catalog + unified metadata (copied, small). |
| - MANIFEST.json + INDEX.md : full inventory (counts, sizes, sources, qdrant points). |
| |
| Disk-safe: big files are symlinked, only the merged text + small sidecars are written. |
| """ |
| import json |
| import os |
| import shutil |
| from pathlib import Path |
|
|
| ROOT = Path("/Users/dmpantiu/copernicus_mcp") |
| OUT = ROOT / "rag_bundle" |
|
|
| |
| SOURCES = [ |
| ("marine_docs", "marine_rag/out/chunks.jsonl", "marine_rag/out/chunks_embedded.jsonl"), |
| ("cds_docs", "deep_docs/chunks.jsonl", "deep_docs/chunks_embedded.jsonl"), |
| ("eqc_qa", "eqc_qa/chunks.jsonl", "eqc_qa/chunks_embedded.jsonl"), |
| ("copernicus_docs", "marine_rag/out/cds_cards_chunks.jsonl", "marine_rag/out/cds_cards_embedded.jsonl"), |
| ("publications", "pubs_rag/out/chunks.jsonl", "pubs_rag/out/chunks_embedded.jsonl"), |
| ] |
| RAW_DIRS = ["marine_parsed", "deep_docs/parsed", "eqc_qa/parsed", "eqc_qa/notebooks_code"] |
| SIDECARS = ["eqc_qa/notebooks_by_dataset.json", "marine_rag/out/catalog.json"] |
|
|
|
|
| def norm_row(collection, o): |
| """Unified minimal schema (drop embeddings; keep text + key metadata).""" |
| return { |
| "collection": collection, |
| "chunk_id": o.get("chunk_id"), |
| "doc_type": o.get("doc_type") or o.get("chunk_type"), |
| "store": o.get("store"), |
| "product_id": o.get("product_id"), |
| "dataset_ids": o.get("dataset_ids") or ([o["dataset_id"]] if o.get("dataset_id") else None), |
| "doc_id": o.get("doc_id"), |
| "doc_url": o.get("doc_url"), |
| "title": o.get("title") or o.get("product_title") or o.get("doc_title"), |
| "section": o.get("section") or o.get("section_path"), |
| "token_count": o.get("token_count"), |
| "text_raw": o.get("text_raw") or o.get("text_with_prefix") or "", |
| } |
|
|
|
|
| def link(src: Path, dst: Path): |
| if dst.exists() or dst.is_symlink(): |
| dst.unlink() |
| if src.exists(): |
| dst.symlink_to(src) |
| return True |
| return False |
|
|
|
|
| def main(): |
| for sub in ("embedded", "source_chunks", "raw", "sidecars"): |
| (OUT / sub).mkdir(parents=True, exist_ok=True) |
|
|
| manifest = {"collections": [], "raw_dirs": [], "sidecars": [], "totals": {}} |
| all_path = OUT / "all_chunks.jsonl" |
| seen = set() |
| total_chunks = 0 |
|
|
| with open(all_path, "w", encoding="utf-8") as out: |
| for coll, chunks_rel, emb_rel in SOURCES: |
| src = ROOT / chunks_rel |
| entry = {"collection": coll, "source_chunks": chunks_rel, |
| "embedded": emb_rel, "chunks_written": 0, "duplicates_skipped": 0, |
| "source_exists": src.exists()} |
| if src.exists(): |
| for line in open(src, encoding="utf-8"): |
| line = line.strip() |
| if not line: |
| continue |
| o = json.loads(line) |
| cid = o.get("chunk_id") |
| key = (coll, cid) |
| if cid and key in seen: |
| entry["duplicates_skipped"] += 1 |
| continue |
| seen.add(key) |
| out.write(json.dumps(norm_row(coll, o), ensure_ascii=False) + "\n") |
| entry["chunks_written"] += 1 |
| total_chunks += 1 |
| |
| link(src, OUT / "source_chunks" / f"{coll}__{src.name}") |
| emb = ROOT / emb_rel |
| entry["embedded_exists"] = emb.exists() |
| if emb.exists(): |
| entry["embedded_bytes"] = emb.stat().st_size |
| link(emb, OUT / "embedded" / f"{coll}__{emb.name}") |
| manifest["collections"].append(entry) |
|
|
| |
| for rd in RAW_DIRS: |
| src = ROOT / rd |
| if src.is_dir(): |
| n_md = sum(1 for _ in src.rglob("*.md")) |
| link(src, OUT / "raw" / rd.replace("/", "__")) |
| manifest["raw_dirs"].append({"dir": rd, "md_files": n_md}) |
|
|
| |
| for sc in SIDECARS: |
| src = ROOT / sc |
| if src.exists(): |
| dst = OUT / "sidecars" / src.name |
| shutil.copy2(src, dst) |
| manifest["sidecars"].append({"file": sc, "bytes": src.stat().st_size}) |
|
|
| manifest["totals"] = { |
| "unified_text_chunks": total_chunks, |
| "all_chunks_jsonl_bytes": all_path.stat().st_size, |
| "collections": len(SOURCES), |
| } |
| (OUT / "MANIFEST.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2)) |
|
|
| |
| lines = ["# RAG bundle — consolidated corpus\n", |
| f"Unified text chunks: **{total_chunks:,}** in `all_chunks.jsonl` " |
| f"({all_path.stat().st_size/1e6:.0f} MB, embeddings stripped)\n", |
| "## Collections\n", |
| "| collection | text chunks | source | embedded |", |
| "|---|--:|---|---|"] |
| for e in manifest["collections"]: |
| eb = f"{e.get('embedded_bytes',0)/1e6:.0f}MB" if e.get("embedded_exists") else "—" |
| lines.append(f"| {e['collection']} | {e['chunks_written']:,} | " |
| f"`{e['source_chunks']}` | {eb} |") |
| lines += ["\n## Raw markdown (symlinked in raw/)\n", |
| "| dir | md files |", "|---|--:|"] |
| for r in manifest["raw_dirs"]: |
| lines.append(f"| {r['dir']} | {r['md_files']:,} |") |
| lines += ["\n## Sidecars (copied)\n"] + [f"- `{s['file']}`" for s in manifest["sidecars"]] |
| lines += ["\n## Layout", |
| "- `all_chunks.jsonl` — every chunk, unified schema, `collection` field", |
| "- `embedded/` — symlinks to vector files (768-d gemini)", |
| "- `source_chunks/` — symlinks to per-collection source jsonl", |
| "- `raw/` — symlinks to parsed-markdown trees", |
| "- `sidecars/` — notebook code map + catalog"] |
| (OUT / "INDEX.md").write_text("\n".join(lines) + "\n") |
|
|
| print(json.dumps(manifest["totals"], indent=2)) |
| for e in manifest["collections"]: |
| print(f" {e['collection']:16s} {e['chunks_written']:>7,} chunks " |
| f"(dupes {e['duplicates_skipped']})") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
