Upload folder using huggingface_hub

scripts/build_bundle.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+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"
+
+# (collection, source chunks.jsonl [text], embedded.jsonl, id_field)
+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
+                # symlinks
+                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)
+
+    # raw dirs (symlink)
+    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})
+
+    # sidecars (copy — small)
+    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))
+
+    # human-readable index
+    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()

scripts/build_rag_tree.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+# build_rag_tree.sh — assemble the curated RAG/ view as SYMLINKS only.
+# Physically moves NOTHING: originals stay put, live Qdrant indexes keep working.
+# Re-runnable (idempotent): clears only the symlinks it manages, then relinks.
+set -uo pipefail
+ROOT=/Users/dmpantiu/copernicus_mcp
+RAG=$ROOT/RAG
+cd "$ROOT"
+
+ln_safe() {  # ln_safe <abs-target> <link-path>
+  local tgt="$1" lnk="$2"
+  if [ ! -e "$tgt" ]; then echo "  MISS  $tgt (skip $lnk)"; return; fi
+  rm -f "$lnk"
+  ln -s "$tgt" "$lnk"
+  echo "  link  ${lnk#$RAG/}  ->  ${tgt#$ROOT/}"
+}
+
+mkdir -p "$RAG"/{originals,chunks,indexes,pipeline,metadata,publications}
+
+echo "== 00 originals (raw parsed / harvested source docs) =="
+mkdir -p "$RAG"/originals
+ln_safe "$ROOT/marine_parsed"            "$RAG/originals/cmems_marine_parsed"
+ln_safe "$ROOT/deep_docs/parsed"         "$RAG/originals/cds_ads_ewds_parsed"
+ln_safe "$ROOT/eqc_qa/parsed"            "$RAG/originals/eqc_reports"
+ln_safe "$ROOT/eqc_qa/notebooks_code"    "$RAG/originals/notebooks_code"
+ln_safe "$ROOT/notebook_harvest"         "$RAG/originals/notebook_harvest"
+
+echo "== 01 chunks (ready text chunks + embedded vectors) =="
+mkdir -p "$RAG"/chunks/{marine_docs,cds_docs,cards,eqc_qa,publications}
+ln_safe "$ROOT/marine_rag/out/chunks.jsonl"           "$RAG/chunks/marine_docs/chunks.jsonl"
+ln_safe "$ROOT/marine_rag/out/chunks_embedded.jsonl"  "$RAG/chunks/marine_docs/chunks_embedded.jsonl"
+ln_safe "$ROOT/deep_docs/chunks.jsonl"                "$RAG/chunks/cds_docs/chunks.jsonl"
+ln_safe "$ROOT/deep_docs/chunks_embedded.jsonl"       "$RAG/chunks/cds_docs/chunks_embedded.jsonl"
+ln_safe "$ROOT/marine_rag/out/cds_cards_chunks.jsonl"   "$RAG/chunks/cards/cds_cards_chunks.jsonl"
+ln_safe "$ROOT/marine_rag/out/cds_cards_embedded.jsonl" "$RAG/chunks/cards/cds_cards_embedded.jsonl"
+ln_safe "$ROOT/eqc_qa/chunks.jsonl"                   "$RAG/chunks/eqc_qa/chunks.jsonl"
+ln_safe "$ROOT/eqc_qa/chunks_embedded.jsonl"          "$RAG/chunks/eqc_qa/chunks_embedded.jsonl"
+# publications/chunks -> filled after L3 parse (slot lives under publications/)
+
+echo "== 02 indexes (LIVE Qdrant collections — symlinked, do not move) =="
+mkdir -p "$RAG"/indexes
+ln_safe "$ROOT/marine_rag/out/qdrant_db"  "$RAG/indexes/marine_docs__copernicus_docs"
+ln_safe "$ROOT/deep_docs/qdrant_db"       "$RAG/indexes/cds_docs"
+ln_safe "$ROOT/eqc_qa/qdrant_db"          "$RAG/indexes/eqc_qa"
+ln_safe "$ROOT/pubs_rag/qdrant_db"        "$RAG/indexes/publications"
+
+echo "== 03 pipeline (build/embed/load scripts, by store) =="
+mkdir -p "$RAG"/pipeline/{marine_cmems,cds_ads_ewds,eqc_notebooks,cards,server}
+for f in "$ROOT"/marine_rag/*.py;  do ln_safe "$f" "$RAG/pipeline/marine_cmems/$(basename "$f")"; done
+for f in "$ROOT"/deep_docs/*.py;   do ln_safe "$f" "$RAG/pipeline/cds_ads_ewds/$(basename "$f")"; done
+for f in "$ROOT"/eqc_qa/*.py;      do ln_safe "$f" "$RAG/pipeline/eqc_notebooks/$(basename "$f")"; done
+ln_safe "$ROOT/marine_rag/build_cds_cards.py"        "$RAG/pipeline/cards/build_cds_cards.py"
+ln_safe "$ROOT/marine_rag/build_missing_cds_cards.py" "$RAG/pipeline/cards/build_missing_cds_cards.py"
+ln_safe "$ROOT/marine_rag/embed_cds_cards.py"        "$RAG/pipeline/cards/embed_cds_cards.py"
+ln_safe "$ROOT/marine_rag/load_copernicus_docs.py"   "$RAG/pipeline/cards/load_copernicus_docs.py"
+ln_safe "$ROOT/marine_rag/rag_server.py"             "$RAG/pipeline/server/rag_server.py"
+ln_safe "$ROOT/marine_rag/RAG_SERVER.md"             "$RAG/pipeline/server/RAG_SERVER.md"
+
+echo "== 04 metadata (catalogs, universe, sidecars, manifests) =="
+mkdir -p "$RAG"/metadata
+ln_safe "$ROOT/meta_harvest/unified_metadata.json"   "$RAG/metadata/unified_metadata.json"
+ln_safe "$ROOT/meta_harvest/deep_doc_plan.json"      "$RAG/metadata/deep_doc_plan.json"
+ln_safe "$ROOT/marine_rag/out/catalog.json"          "$RAG/metadata/cmems_catalog.json"
+ln_safe "$ROOT/marine_rag/out/catalog_summary.json"  "$RAG/metadata/cmems_catalog_summary.json"
+ln_safe "$ROOT/eqc_qa/notebooks_by_dataset.json"     "$RAG/metadata/notebooks_by_dataset.json"
+ln_safe "$ROOT/deep_docs/manifest.jsonl"             "$RAG/metadata/deep_docs_manifest.jsonl"
+
+echo "== 05 publications (L3 track — the slot articles plug into) =="
+mkdir -p "$RAG"/publications/{originals_pdfs,parsed,chunks,pipeline}
+ln_safe "$ROOT/publications/pdfs"          "$RAG/publications/originals_pdfs/registry"
+ln_safe "$ROOT/publications/pdfs_openalex" "$RAG/publications/originals_pdfs/openalex"
+ln_safe "$ROOT/publications/pdfs_extended" "$RAG/publications/originals_pdfs/extended_oa"
+ln_safe "$ROOT/publications/extended"      "$RAG/publications/corpus"
+ln_safe "$ROOT/pubs_rag/qdrant_db"         "$RAG/publications/index"
+for f in "$ROOT"/publications/*.py; do ln_safe "$f" "$RAG/publications/pipeline/$(basename "$f")"; done
+
+echo "DONE. Tree at $RAG (symlinks only; nothing moved)."

scripts/deep_docs/chunk_docs.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+chunk_docs.py — section-aware chunking of the fetched CDS/ADS/EWDS deep docs.
+
+Mirrors eqc_qa/chunk_reports.py. One chunk-set per UNIQUE doc (a doc shared by
+several datasets is chunked once; its chunks carry dataset_ids[] = all datasets
+that reference it, so the server can filter per dataset).
+
+Input : deep_docs/manifest.jsonl (status==ok rows) + their parsed/*.md
+Output: deep_docs/chunks.jsonl — payload:
+  chunk_id, doc_url, doc_title, doc_kind, dataset_ids[], store, stores[],
+  section, chunk_index, token_count, text_raw, text_with_prefix
+"""
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+import tiktoken
+
+ROOT = Path(__file__).resolve().parent.parent
+MANIFEST = ROOT / "deep_docs" / "manifest.jsonl"
+OUT = ROOT / "deep_docs" / "chunks.jsonl"
+META = ROOT / "meta_harvest" / "unified_metadata.json"
+
+MAX_TOKENS = 1000
+MIN_QUALITY_TOKENS = 30
+MIN_TOKENS = 80
+OVERLAP_RATIO = 0.05
+_enc = tiktoken.get_encoding("cl100k_base")
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def count_tokens(t): return len(_enc.encode(t))
+
+
+HEADING = re.compile(r"^(#{1,4})\s+(.*)$")
+
+
+def parse_sections(md):
+    lines = md.splitlines()
+    stack, cur_path, buf, sections, in_fence = [], "[intro]", [], [], False
+
+    def flush():
+        body = "\n".join(buf).strip()
+        if body:
+            sections.append((cur_path, body))
+    for ln in lines:
+        if ln.lstrip().startswith("```"):
+            in_fence = not in_fence; buf.append(ln); continue
+        m = None if in_fence else HEADING.match(ln)
+        if m:
+            flush(); buf = []
+            level = len(m.group(1))
+            title = re.sub(r"[#*`]", "", m.group(2)).strip()
+            while stack and stack[-1][0] >= level:
+                stack.pop()
+            stack.append((level, title))
+            cur_path = " > ".join(t for _, t in stack) or "[section]"
+        else:
+            buf.append(ln)
+    flush()
+    return sections
+
+
+def split_by_tokens(text, max_tokens):
+    paras = re.split(r"\n\s*\n", text)
+    chunks, cur, cur_tok = [], [], 0
+    for p in paras:
+        p = p.strip()
+        if not p:
+            continue
+        pt = count_tokens(p)
+        if pt > max_tokens:
+            if cur:
+                chunks.append("\n\n".join(cur)); cur, cur_tok = [], 0
+            ids = _enc.encode(p)
+            for i in range(0, len(ids), max_tokens):
+                chunks.append(_enc.decode(ids[i:i + max_tokens]))
+            continue
+        if cur_tok + pt > max_tokens and cur:
+            chunks.append("\n\n".join(cur)); cur, cur_tok = [], 0
+        cur.append(p); cur_tok += pt
+    if cur:
+        chunks.append("\n\n".join(cur))
+    return chunks
+
+
+def add_overlap(chunks, ratio):
+    if len(chunks) < 2 or ratio <= 0:
+        return chunks
+    out = [chunks[0]]
+    for i in range(1, len(chunks)):
+        ptoks = _enc.encode(chunks[i - 1])
+        n = max(1, int(len(ptoks) * ratio))
+        out.append(_enc.decode(ptoks[-n:]) + "\n\n" + chunks[i])
+    return out
+
+
+def main():
+    meta = json.loads(META.read_text()) if META.exists() else {}
+    store_of = {}
+    for k, v in meta.items():
+        pid = v.get("product_id") or k
+        store_of[pid] = (v.get("store") or "").upper()
+
+    recs = [json.loads(l) for l in MANIFEST.read_text().splitlines() if l.strip()]
+    ok = [r for r in recs if r["status"] == "ok" and r.get("md_path")]
+    # dedup by url
+    seen_url = {}
+    for r in ok:
+        seen_url[r["url"]] = r
+    log(f"chunking {len(seen_url)} unique docs")
+
+    n_docs = n_chunks = 0
+    with open(OUT, "w", encoding="utf-8") as f:
+        for url, r in seen_url.items():
+            p = ROOT / r["md_path"]
+            if not p.exists():
+                continue
+            md = p.read_text(encoding="utf-8", errors="replace")
+            dsids = sorted(set(r["datasets"]))
+            stores = sorted({store_of.get(d, "") for d in dsids} - {""})
+            store = stores[0] if stores else "CDS"
+            title = r.get("title") or ""
+            counter = 0
+            seen_h = set()
+            for section, body in parse_sections(md):
+                body = re.sub(r"\n{3,}", "\n\n", body).strip()
+                if not body:
+                    continue
+                raw = split_by_tokens(body, MAX_TOKENS)
+                if len(raw) > 1:
+                    raw = add_overlap(raw, OVERLAP_RATIO)
+                for ct in raw:
+                    ct = ct.strip()
+                    if count_tokens(ct) < MIN_QUALITY_TOKENS:
+                        continue
+                    h = hashlib.md5(ct.encode()).hexdigest()
+                    if h in seen_h:
+                        continue
+                    seen_h.add(h)
+                    prefix = (f'Copernicus documentation: "{title}"\n'
+                              f'Dataset(s): {", ".join(dsids[:6])} [{store}]\n'
+                              f'Section: {section}\n---\n')
+                    twp = prefix + ct
+                    f.write(json.dumps({
+                        "chunk_id": f"{hashlib.md5(url.encode()).hexdigest()[:12]}__{h[:12]}",
+                        "doc_url": url,
+                        "doc_title": title,
+                        "doc_kind": r.get("kind"),
+                        "dataset_ids": dsids,
+                        "store": store,
+                        "stores": stores,
+                        "doc_type": "DEEP_DOC",
+                        "section": section,
+                        "chunk_index": counter,
+                        "token_count": count_tokens(twp),
+                        "text_raw": ct,
+                        "text_with_prefix": twp,
+                    }, ensure_ascii=False) + "\n")
+                    counter += 1
+            n_docs += 1
+            n_chunks += counter
+    toks = sum(json.loads(l)["token_count"] for l in open(OUT))
+    log(f"DONE: {n_docs} docs -> {n_chunks} chunks ({toks:,} tokens) -> {OUT}")
+    log(f"est batch embed ${toks/1e6*0.125:.2f} (realtime ${toks/1e6*0.25:.2f})")
+
+
+if __name__ == "__main__":
+    main()

scripts/deep_docs/embed_load.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+embed_load.py — embed the CDS/ADS/EWDS deep-doc chunks (gemini-embedding-2-preview,
+768-dim, RETRIEVAL_DOCUMENT, L2-norm) and load them into Qdrant `cds_docs`
+(dense + BM25 sparse), in a SEPARATE db (deep_docs/qdrant_db) so it never
+contends the marine_docs lock.
+
+Phases (resumable):
+  --phase embed   chunks.jsonl -> chunks_embedded.jsonl (checkpointed, skips done)
+  --phase load    chunks_embedded.jsonl -> Qdrant cds_docs
+  --phase all     embed then load (default)
+
+Env: BATCH=<n> embed batch size (default 32); SAMPLE_N=<n> smoke test.
+"""
+import argparse
+import json
+import os
+import sys
+import time
+import uuid
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parent.parent
+CHUNKS = ROOT / "deep_docs" / "chunks.jsonl"
+EMB = ROOT / "deep_docs" / "chunks_embedded.jsonl"
+LOCAL_DB = ROOT / "deep_docs" / "qdrant_db"
+COLLECTION = "cds_docs"
+DENSE_DIM = 768
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def resolve_key() -> str:
+    for var in ("GOOGLE_API_KEY", "GEMINI_API_KEY"):
+        if os.environ.get(var):
+            return os.environ[var]
+    for env in (ROOT / ".env", Path("/Users/dmpantiu/cmip6/cmip6_gpt/.env")):
+        if env.exists():
+            for line in env.read_text().splitlines():
+                line = line.strip()
+                if "api_key" in line.lower() and "=" in line and not line.startswith("#"):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("No Gemini API key.")
+
+
+def _norm(vals):
+    v = np.array(list(vals), dtype=np.float32)
+    n = np.linalg.norm(v)
+    return (v / n).tolist() if n > 0 else v.tolist()
+
+
+def embed_phase(workers: int, sample: int):
+    """One embedding per chunk (the API returns a single vector per call),
+    parallelised with a thread pool for throughput."""
+    import threading
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    from google import genai
+    from google.genai import types
+    client = genai.Client(api_key=resolve_key())
+    cfg = types.EmbedContentConfig(task_type="RETRIEVAL_DOCUMENT",
+                                   output_dimensionality=DENSE_DIM)
+
+    done = set()
+    if EMB.exists():
+        for line in EMB.read_text().splitlines():
+            if line.strip():
+                done.add(json.loads(line)["chunk_id"])
+    rows = [json.loads(l) for l in CHUNKS.read_text().splitlines() if l.strip()]
+    todo = [r for r in rows if r["chunk_id"] not in done]
+    if sample:
+        todo = todo[:sample]
+    log(f"embed: total={len(rows)} done={len(done)} todo={len(todo)} workers={workers}")
+
+    lock = threading.Lock()
+    out = open(EMB, "a", encoding="utf-8")
+    state = {"n": 0, "fail": 0}
+
+    def work(rec):
+        for attempt in range(5):
+            try:
+                r = client.models.embed_content(
+                    model="gemini-embedding-2-preview",
+                    contents=rec["text_with_prefix"], config=cfg)
+                rec["embedding"] = _norm(r.embeddings[0].values)
+                with lock:
+                    out.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                    out.flush()
+                    state["n"] += 1
+                    if state["n"] % 500 == 0:
+                        log(f"  embedded {state['n']}/{len(todo)}")
+                return
+            except Exception as e:
+                if attempt == 4:
+                    with lock:
+                        state["fail"] += 1
+                    log(f"  chunk {rec['chunk_id']} PERMA-FAIL ({repr(e)[:80]})")
+                else:
+                    time.sleep(1.5 * (attempt + 1))
+
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        list(as_completed(ex.submit(work, r) for r in todo))
+    out.close()
+    log(f"EMBED DONE: +{state['n']} (fail {state['fail']}, total file now {len(done)+state['n']})")
+
+
+def load_phase(recreate: bool):
+    from qdrant_client import QdrantClient, models
+    from fastembed import SparseTextEmbedding
+    bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+
+    def to_sparse(text):
+        r = list(bm25.embed([text]))[0]
+        return models.SparseVector(indices=r.indices.tolist(), values=r.values.tolist())
+
+    client = QdrantClient(path=str(LOCAL_DB))
+    names = [c.name for c in client.get_collections().collections]
+    if COLLECTION in names and recreate:
+        client.delete_collection(COLLECTION); names.remove(COLLECTION)
+    if COLLECTION not in names:
+        client.create_collection(
+            collection_name=COLLECTION,
+            vectors_config={"dense": models.VectorParams(size=DENSE_DIM, distance=models.Distance.COSINE)},
+            sparse_vectors_config={"sparse": models.SparseVectorParams(modifier=models.Modifier.IDF)},
+        )
+        for field in ("dataset_ids", "store", "doc_type", "doc_url"):
+            client.create_payload_index(collection_name=COLLECTION, field_name=field,
+                                        field_schema=models.PayloadSchemaType.KEYWORD)
+        log(f"created '{COLLECTION}' (dense+sparse, 4 indexes)")
+
+    buf, total, t0 = [], 0, time.time()
+    for line in EMB.read_text().splitlines():
+        if not line.strip():
+            continue
+        c = json.loads(line)
+        emb = c.get("embedding")
+        if not emb:
+            continue
+        raw = c.get("text_raw", "")
+        buf.append(models.PointStruct(
+            id=str(uuid.uuid5(uuid.NAMESPACE_DNS, c["chunk_id"])),
+            vector={"dense": emb, "sparse": to_sparse(raw)},
+            payload={
+                "chunk_id": c["chunk_id"], "dataset_ids": c.get("dataset_ids", []),
+                "store": c.get("store", ""), "stores": c.get("stores", []),
+                "doc_url": c.get("doc_url", ""), "doc_title": c.get("doc_title", ""),
+                "doc_kind": c.get("doc_kind", ""), "doc_type": "DEEP_DOC",
+                "section": c.get("section", ""), "text_raw": raw[:2500],
+            }))
+        if len(buf) >= 400:
+            client.upsert(collection_name=COLLECTION, points=buf)
+            total += len(buf); buf = []
+            log(f"  loaded {total} ({total/(time.time()-t0):.0f}/s)")
+    if buf:
+        client.upsert(collection_name=COLLECTION, points=buf); total += len(buf)
+    log(f"LOAD DONE: {total} points; collection now {client.get_collection(COLLECTION).points_count}")
+    client.close()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--phase", choices=("embed", "load", "all"), default="all")
+    ap.add_argument("--recreate", action="store_true")
+    a = ap.parse_args()
+    workers = int(os.environ.get("WORKERS", "10"))
+    sample = int(os.environ.get("SAMPLE_N", "0"))
+    if a.phase in ("embed", "all"):
+        embed_phase(workers, sample)
+    if a.phase in ("load", "all") and not sample:
+        load_phase(a.recreate)
+
+
+if __name__ == "__main__":
+    main()

scripts/deep_docs/fetch_parse.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+fetch_parse.py — fetch & text-extract the CDS/ADS/EWDS deep documentation
+(Confluence wiki pages + PDFs + service webpages) so the non-marine stores get
+the same deep-doc RAG depth as CMEMS marine.
+
+Input : meta_harvest/deep_doc_plan.json   dataset_id -> [{title,url,kind}]
+Output: deep_docs/parsed/<urlhash>.md     cleaned text per unique URL
+        deep_docs/manifest.jsonl          one line per URL (checkpoint: resumable)
+
+No VLM needed: Confluence/webpages via requests+bs4+markdownify, PDFs via PyMuPDF.
+Env: SAMPLE_N=<n> to only process the first n URLs (smoke test).
+"""
+import json
+import os
+import re
+import sys
+import hashlib
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import requests
+from bs4 import BeautifulSoup
+from markdownify import markdownify as mdify
+import fitz  # PyMuPDF
+
+ROOT = Path(__file__).resolve().parent.parent
+PLAN = ROOT / "meta_harvest" / "deep_doc_plan.json"
+OUTDIR = ROOT / "deep_docs" / "parsed"
+MANIFEST = ROOT / "deep_docs" / "manifest.jsonl"
+UA = {"User-Agent": "Mozilla/5.0 (copernicus-rag deep-doc harvester; research use)"}
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def uhash(url):
+    return hashlib.md5(url.encode()).hexdigest()[:16]
+
+
+def clean_md(md: str) -> str:
+    md = re.sub(r"\n{3,}", "\n\n", md)
+    md = re.sub(r"[ \t]+\n", "\n", md)
+    # drop obvious confluence chrome lines
+    drop = ("Skip to", "Configure Space tools", "Space shortcuts", "Copyright ©",
+            "Powered by Atlassian", "Evaluate Confluence", "You are viewing")
+    lines = [ln for ln in md.splitlines() if not any(d in ln for d in drop)]
+    return "\n".join(lines).strip()
+
+
+def parse_html(html: str) -> str:
+    soup = BeautifulSoup(html, "html.parser")
+    for t in soup(["script", "style", "nav", "header", "footer", "noscript", "form"]):
+        t.decompose()
+    node = (soup.select_one("#main-content") or soup.select_one(".wiki-content")
+            or soup.select_one("div[role=main]") or soup.select_one("main")
+            or soup.select_one("article") or soup.body or soup)
+    md = mdify(str(node), heading_style="ATX", strip=["img"])
+    return clean_md(md)
+
+
+def parse_pdf(content: bytes) -> str:
+    doc = fitz.open(stream=content, filetype="pdf")
+    parts = [page.get_text("text") for page in doc]
+    doc.close()
+    return clean_md("\n\n".join(parts))
+
+
+def fetch_one(url: str, kind: str) -> tuple[str, str]:
+    """Return (markdown, status). status in {ok, empty, http_<code>, error}."""
+    try:
+        r = requests.get(url, headers=UA, timeout=40, allow_redirects=True)
+        if r.status_code != 200:
+            return "", f"http_{r.status_code}"
+        ct = r.headers.get("content-type", "").lower()
+        if kind == "pdf" or "application/pdf" in ct or url.lower().split("?")[0].endswith(".pdf"):
+            md = parse_pdf(r.content)
+        else:
+            md = parse_html(r.text)
+        return md, ("ok" if len(md) >= 200 else "empty")
+    except Exception as e:
+        return "", f"error:{type(e).__name__}"
+
+
+def main():
+    OUTDIR.mkdir(parents=True, exist_ok=True)
+    plan = json.loads(PLAN.read_text())
+    # unique url -> {title, kind, datasets:[]}
+    urls: dict[str, dict] = {}
+    for dsid, docs in plan.items():
+        for d in docs:
+            u = d["url"]
+            e = urls.setdefault(u, {"title": d.get("title", ""), "kind": d.get("kind"), "datasets": []})
+            e["datasets"].append(dsid)
+
+    done = set()
+    if MANIFEST.exists():
+        for line in MANIFEST.read_text().splitlines():
+            if line.strip():
+                done.add(json.loads(line)["url"])
+    todo = [u for u in urls if u not in done]
+    sample = int(os.environ.get("SAMPLE_N", "0"))
+    if sample:
+        todo = todo[:sample]
+    log(f"unique urls={len(urls)} done={len(done)} todo={len(todo)}"
+        + (f" (SAMPLE {sample})" if sample else ""))
+
+    workers = int(os.environ.get("WORKERS", "10"))
+    lock = threading.Lock()
+    counts = {"ok": 0, "done": 0}
+    mf = open(MANIFEST, "a", encoding="utf-8")
+
+    def work(url):
+        meta = urls[url]
+        md, status = fetch_one(url, meta["kind"])
+        rec = {"url": url, "kind": meta["kind"], "title": meta["title"],
+               "datasets": meta["datasets"], "status": status,
+               "n_chars": len(md), "md_path": ""}
+        if status == "ok":
+            p = OUTDIR / f"{uhash(url)}.md"
+            header = f"# {meta['title']}\n\n<!-- source: {url} -->\n\n"
+            p.write_text(header + md, encoding="utf-8")
+            rec["md_path"] = str(p.relative_to(ROOT))
+        with lock:
+            mf.write(json.dumps(rec, ensure_ascii=False) + "\n")
+            mf.flush()
+            counts["done"] += 1
+            counts["ok"] += status == "ok"
+            if counts["done"] % 40 == 0:
+                log(f"  {counts['done']}/{len(todo)}  ok={counts['ok']}")
+
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        list(as_completed(ex.submit(work, u) for u in todo))
+    mf.close()
+    log(f"DONE todo={len(todo)} ok={counts['ok']}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/chunk_reports.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+chunk_reports.py — section-aware chunking of parsed EQC QA markdown.
+
+Mirrors marine_rag/chunk_docs.py: ~1000-token section-aware chunks, small
+overlap, tiktoken (cl100k_base ≈ Gemini) budget, a metadata prefix per chunk
+(dataset + report + aspect + section path). Self-contained (no cmip6 import).
+
+Output: eqc_qa/chunks.jsonl — payload fields:
+  chunk_id, report_id, dataset_id, store, doc_type="EQC_QA",
+  aspect, aspect_base, category, section, title, text_raw, text_with_prefix, token_count
+"""
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+import tiktoken
+
+ROOT = Path(__file__).resolve().parent
+PARSED = ROOT / "parsed"
+MANIFEST = ROOT / "reports.jsonl"
+OUT = ROOT / "chunks.jsonl"
+
+MAX_TOKENS = 1000
+MIN_QUALITY_TOKENS = 30
+MIN_TOKENS = 80
+OVERLAP_RATIO = 0.05
+
+_enc = tiktoken.get_encoding("cl100k_base")
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def count_tokens(t: str) -> int:
+    return len(_enc.encode(t))
+
+
+# ── section parsing (markdown heading aware) ─────────────────────────────────
+HEADING = re.compile(r"^(#{1,4})\s+(.*)$")
+
+
+def parse_sections(md: str) -> list[tuple[str, str]]:
+    """Return [(section_path, body_text)] splitting on ATX headings, tracking
+    the heading breadcrumb. Fenced code blocks are left intact (skip heading
+    detection inside ``` fences)."""
+    lines = md.splitlines()
+    stack: list[tuple[int, str]] = []  # (level, title)
+    cur_path = "[intro]"
+    buf: list[str] = []
+    sections: list[tuple[str, str]] = []
+    in_fence = False
+
+    def flush():
+        body = "\n".join(buf).strip()
+        if body:
+            sections.append((cur_path, body))
+
+    for ln in lines:
+        if ln.lstrip().startswith("```"):
+            in_fence = not in_fence
+            buf.append(ln)
+            continue
+        m = None if in_fence else HEADING.match(ln)
+        if m:
+            flush()
+            buf = []
+            level = len(m.group(1))
+            title = re.sub(r"[#*`]", "", m.group(2)).strip()
+            title = re.sub(r"[\U0001F000-\U0001FAFF☀-➿]", "", title).strip()
+            while stack and stack[-1][0] >= level:
+                stack.pop()
+            stack.append((level, title))
+            cur_path = " > ".join(t for _, t in stack) or "[section]"
+        else:
+            buf.append(ln)
+    flush()
+    return sections
+
+
+def strip_noise(t: str) -> str:
+    # collapse admonition fences markers but keep content
+    t = re.sub(r"```\{[^}]*\}", "", t)
+    t = re.sub(r"^:class:.*$", "", t, flags=re.MULTILINE)
+    t = re.sub(r"\n{3,}", "\n\n", t)
+    return t.strip()
+
+
+def split_by_tokens(text: str, max_tokens: int) -> list[str]:
+    """Greedy paragraph-packing; hard-split any oversized paragraph on tokens."""
+    paras = re.split(r"\n\s*\n", text)
+    chunks: list[str] = []
+    cur: list[str] = []
+    cur_tok = 0
+    for p in paras:
+        p = p.strip()
+        if not p:
+            continue
+        pt = count_tokens(p)
+        if pt > max_tokens:
+            if cur:
+                chunks.append("\n\n".join(cur)); cur, cur_tok = [], 0
+            ids = _enc.encode(p)
+            for i in range(0, len(ids), max_tokens):
+                chunks.append(_enc.decode(ids[i:i + max_tokens]))
+            continue
+        if cur_tok + pt > max_tokens and cur:
+            chunks.append("\n\n".join(cur)); cur, cur_tok = [], 0
+        cur.append(p); cur_tok += pt
+    if cur:
+        chunks.append("\n\n".join(cur))
+    return chunks
+
+
+def add_overlap(chunks: list[str], ratio: float) -> list[str]:
+    if len(chunks) < 2 or ratio <= 0:
+        return chunks
+    out = [chunks[0]]
+    for i in range(1, len(chunks)):
+        prev = chunks[i - 1]
+        ptoks = _enc.encode(prev)
+        n = max(1, int(len(ptoks) * ratio))
+        tail = _enc.decode(ptoks[-n:])
+        out.append(tail + "\n\n" + chunks[i])
+    return out
+
+
+def make_prefix(rec: dict, section: str) -> str:
+    ds = rec["matched_dataset_id"] or rec["dataset_id"] or "(unmapped)"
+    return (f'EQC Quality Assessment: "{rec["title"]}"\n'
+            f'Dataset: {ds} [{rec["store"] or "CDS"}]\n'
+            f'Aspect: {rec["aspect"]}  |  Category: {rec["category"]}\n'
+            f'Section: {section}\n---\n')
+
+
+def chunk_report(rec: dict) -> list[dict]:
+    md = (PARSED / Path(rec["md_path"]).name).read_text(encoding="utf-8", errors="replace")
+    sections = parse_sections(md)
+    out: list[dict] = []
+    seen: set[str] = set()
+    counter = 0
+    for section, body in sections:
+        body = strip_noise(body)
+        if not body:
+            continue
+        raw = split_by_tokens(body, MAX_TOKENS)
+        if len(raw) > 1:
+            raw = add_overlap(raw, OVERLAP_RATIO)
+        for ct in raw:
+            ct = ct.strip()
+            if count_tokens(ct) < MIN_QUALITY_TOKENS:
+                continue
+            h = hashlib.md5(ct.encode()).hexdigest()
+            if h in seen:
+                continue
+            seen.add(h)
+            twp = make_prefix(rec, section) + ct
+            out.append({
+                "chunk_id": f"{rec['report_id']}__{h[:12]}",
+                "report_id": rec["report_id"],
+                "dataset_id": rec["matched_dataset_id"] or rec["dataset_id"],
+                "store": rec["store"] or "CDS",
+                "doc_type": "EQC_QA",
+                "aspect": rec["aspect"],
+                "aspect_base": rec["aspect_base"],
+                "category": rec["category"],
+                "match_confidence": rec["match_confidence"],
+                "section": section,
+                "title": rec["title"],
+                "chunk_index": counter,
+                "token_count": count_tokens(twp),
+                "text_raw": ct,
+                "text_with_prefix": twp,
+            })
+            counter += 1
+
+    # merge tiny adjacent chunks within a section
+    merged: list[dict] = []
+    i = 0
+    while i < len(out):
+        c = out[i]
+        if (c["token_count"] < MIN_TOKENS and i + 1 < len(out)
+                and out[i + 1]["section"] == c["section"]):
+            nxt = out[i + 1]
+            mt = c["text_raw"] + "\n\n" + nxt["text_raw"]
+            nxt["text_raw"] = mt
+            nxt["text_with_prefix"] = nxt["text_with_prefix"].split("---\n", 1)[0] + "---\n" + mt
+            nxt["token_count"] = count_tokens(nxt["text_with_prefix"])
+            i += 1
+        else:
+            merged.append(c); i += 1
+    for j, c in enumerate(merged):
+        c["chunk_index"] = j
+    return merged
+
+
+def main() -> None:
+    recs = [json.loads(l) for l in open(MANIFEST)]
+    recs = [r for r in recs if not r["is_template"]]  # skip scaffold
+    log(f"chunking {len(recs)} reports")
+    n_docs = n_chunks = 0
+    with open(OUT, "w", encoding="utf-8") as f:
+        for r in recs:
+            chunks = chunk_report(r)
+            for c in chunks:
+                f.write(json.dumps(c, ensure_ascii=False) + "\n")
+            n_docs += 1
+            n_chunks += len(chunks)
+    toks = 0
+    for l in open(OUT):
+        toks += json.loads(l)["token_count"]
+    log(f"DONE: {n_docs} reports -> {n_chunks} chunks ({toks:,} tokens) -> {OUT}")
+    log(f"avg {n_chunks/n_docs:.1f} chunks/report; est realtime ${toks/1e6*0.25:.2f}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/embed_reports.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""
+embed_reports.py — embed EQC QA chunks with gemini-embedding-2-preview.
+
+LOCKED: gemini-embedding-2-preview, RETRIEVAL_DOCUMENT, 768-dim, L2-normalized.
+IPv4 egress forced (net_ipv4). Key = veretex_api_key in ../.env.
+
+Modes:
+  realtime (default) — resumable streaming; on sustained 429 print how to fall
+                       back to batch and exit non-zero.
+  batch    — submit Gemini Batch API job (schema mirrors marine_rag/embed.py),
+             resumable via --mode poll. Sentinel EMBED_DONE written when >=99%.
+
+Usage:
+  embed_reports.py                 # realtime
+  embed_reports.py --mode batch    # submit batch job
+  embed_reports.py --mode poll     # download completed batch job
+"""
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+# force IPv4 (reuse marine_rag net_ipv4)
+sys.path.insert(0, "/Users/dmpantiu/copernicus_mcp/marine_rag")
+import net_ipv4  # noqa: F401,E402
+
+ROOT = Path(__file__).resolve().parent
+IN = ROOT / "chunks.jsonl"
+OUT = ROOT / "chunks_embedded.jsonl"
+BATCH_INPUT = ROOT / "batch_embed_input.jsonl"
+JOB_FILE = ROOT / "batch_job.txt"
+SENTINEL = ROOT / "EMBED_DONE"
+
+MODEL = "gemini-embedding-2-preview"
+TASK = "RETRIEVAL_DOCUMENT"
+DIM = 768
+# Free-tier gemini-embedding-2 quota is tiny/fluctuating and counts per content.
+# Keep requests small and well-spaced; the finisher loops passes until complete.
+RT_BATCH = 5
+RT_SLEEP = 20.0
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def resolve_key() -> str:
+    for var in ("GOOGLE_API_KEY", "GEMINI_API_KEY"):
+        if os.environ.get(var):
+            return os.environ[var]
+    for env in (Path("/Users/dmpantiu/copernicus_mcp/.env"),
+                Path("/Users/dmpantiu/cmip6/cmip6_gpt/.env")):
+        if env.exists():
+            for line in env.read_text().splitlines():
+                line = line.strip()
+                if "api_key" in line.lower() and "=" in line and not line.startswith("#"):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("No Gemini API key found.")
+
+
+def get_client():
+    from google import genai
+    return genai.Client(api_key=resolve_key())
+
+
+def l2(vec):
+    a = np.array(vec, dtype=np.float32)
+    n = np.linalg.norm(a)
+    return (a / n).tolist() if n > 0 else a.tolist()
+
+
+def load_chunks():
+    return [json.loads(l) for l in open(IN)]
+
+
+def embedded_keys() -> set:
+    keys = set()
+    if OUT.exists():
+        for line in open(OUT):
+            try:
+                keys.add(json.loads(line)["chunk_id"])
+            except Exception:
+                pass
+    return keys
+
+
+def embed_realtime(chunks):
+    from google.genai import types
+    client = get_client()
+    done = embedded_keys()
+    if done:
+        log(f"resume: {len(done)} already embedded")
+    todo = [c for c in chunks if c["chunk_id"] not in done]
+    log(f"to embed: {len(todo)} / {len(chunks)}")
+    n = 0
+    consecutive_429 = 0
+    with open(OUT, "a", encoding="utf-8") as fout:
+        for b in range(0, len(todo), RT_BATCH):
+            batch = todo[b:b + RT_BATCH]
+            # genai 2.10: a list[str] is treated as ONE content -> 1 embedding.
+            # Wrap each text in a Content object to get one embedding per input.
+            contents = [types.Content(parts=[types.Part(text=c["text_with_prefix"])])
+                        for c in batch]
+            ok = False
+            for attempt in range(6):
+                try:
+                    if attempt > 0:
+                        client = get_client()
+                    r = client.models.embed_content(
+                        model=MODEL, contents=contents,
+                        config=types.EmbedContentConfig(
+                            task_type=TASK, output_dimensionality=DIM))
+                    if len(r.embeddings) != len(batch):
+                        raise RuntimeError(
+                            f"embedding count mismatch {len(r.embeddings)}!={len(batch)}")
+                    for c, e in zip(batch, r.embeddings):
+                        c["embedding"] = l2(e.values)
+                        fout.write(json.dumps(c, ensure_ascii=False) + "\n")
+                        n += 1
+                    fout.flush()
+                    ok = True
+                    consecutive_429 = 0
+                    break
+                except Exception as e:
+                    es = str(e)
+                    if "IP address restriction" in es:
+                        raise SystemExit(
+                            "BLOCKED: Gemini key IP restriction. Whitelist this host's IP.")
+                    if any(k in es for k in ("429", "RESOURCE_EXHAUSTED", "Quota exceeded")):
+                        wait = 35
+                    elif "client has been closed" in es:
+                        wait = 2
+                    else:
+                        wait = min(8 * (2 ** attempt), 60)
+                    log(f"  retry {attempt+1}/6 in {wait}s: {repr(e)[:120]}")
+                    time.sleep(wait)
+            if not ok:
+                consecutive_429 += 1
+                log(f"  FATAL skip batch of {len(batch)}")
+                if consecutive_429 >= 3:
+                    log("SUSTAINED 429 — realtime quota exhausted.")
+                    log("Fall back to batch: python embed_reports.py --mode batch ; "
+                        "then: python embed_reports.py --mode poll")
+                    sys.exit(2)
+            if n and n % 400 == 0:
+                log(f"  [{n}/{len(todo)}]")
+            time.sleep(RT_SLEEP)
+    finalize(chunks)
+    log(f"DONE realtime: {n} newly embedded -> {OUT}")
+
+
+# ── batch fallback (mirrors marine_rag/embed.py) ─────────────────────────────
+def prepare_batch(chunks):
+    done = embedded_keys()
+    todo = [c for c in chunks if c["chunk_id"] not in done]
+    with open(BATCH_INPUT, "w", encoding="utf-8") as f:
+        for c in todo:
+            f.write(json.dumps({
+                "key": c["chunk_id"],
+                "request": {
+                    "content": {"parts": [{"text": c["text_with_prefix"]}]},
+                    "task_type": TASK,
+                    "output_dimensionality": DIM,
+                }}, ensure_ascii=False) + "\n")
+    log(f"batch input: {BATCH_INPUT} ({len(todo)} reqs)")
+    return todo
+
+
+def submit_batch(chunks):
+    prepare_batch(chunks)
+    client = get_client()
+    up = client.files.upload(file=str(BATCH_INPUT),
+                             config={"display_name": "eqc_qa_embed", "mime_type": "jsonl"})
+    job = client.batches.create_embeddings(
+        model=MODEL, src={"file_name": up.name},
+        config={"display_name": "eqc_qa_embeddings"})
+    JOB_FILE.write_text(job.name)
+    log(f"job: {job.name} state: {job.state} (saved {JOB_FILE})")
+
+
+def _extract_values(resp: dict):
+    for path in (("response", "embeddings"), ("response", "embedding"),
+                 ("embeddings",), ("embedding",)):
+        node = resp; ok = True
+        for k in path:
+            if isinstance(node, dict) and k in node:
+                node = node[k]
+            else:
+                ok = False; break
+        if not ok:
+            continue
+        if isinstance(node, list) and node and isinstance(node[0], dict) and "values" in node[0]:
+            return node[0]["values"]
+        if isinstance(node, dict) and "values" in node:
+            return node["values"]
+    return None
+
+
+def poll_batch(chunks, wait=True):
+    client = get_client()
+    name = JOB_FILE.read_text().strip()
+    while True:
+        job = client.batches.get(name=name)
+        state = str(job.state)
+        log(f"  job {name}: {state}")
+        if any(s in state for s in ("SUCCEEDED", "FAILED", "CANCELLED", "EXPIRED")):
+            break
+        if not wait:
+            return
+        time.sleep(30)
+    if "SUCCEEDED" not in state:
+        log(f"job not successful: {state}"); return
+    by_key = {c["chunk_id"]: c for c in chunks}
+    dest = getattr(job, "dest", None)
+    fn = getattr(dest, "file_name", None) if dest else None
+    lines = []
+    if fn:
+        lines = client.files.download(file=fn).decode("utf-8").strip().split("\n")
+    elif dest and getattr(dest, "inlined_responses", None):
+        lines = [json.dumps(r) for r in dest.inlined_responses]
+    n = 0
+    with open(OUT, "a", encoding="utf-8") as fout:
+        for line in lines:
+            if not line.strip():
+                continue
+            r = json.loads(line)
+            k = r.get("key") or r.get("custom_id")
+            vals = _extract_values(r)
+            if k in by_key and vals:
+                c = dict(by_key[k]); c["embedding"] = l2(vals)
+                fout.write(json.dumps(c, ensure_ascii=False) + "\n"); n += 1
+    log(f"downloaded {n} embeddings -> {OUT}")
+    finalize(chunks)
+
+
+def finalize(chunks):
+    got = embedded_keys()
+    frac = len(got) / max(1, len(chunks))
+    log(f"coverage: {len(got)}/{len(chunks)} = {frac:.1%}")
+    if frac >= 0.99:
+        SENTINEL.write_text(f"{len(got)}/{len(chunks)}\n")
+        log(f"SENTINEL {SENTINEL} written")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", choices=["realtime", "batch", "poll"], default="realtime")
+    a = ap.parse_args()
+    chunks = load_chunks()
+    toks = sum(c["token_count"] for c in chunks)
+    log(f"chunks={len(chunks):,} tokens={toks:,} est ${toks/1e6*0.25:.2f}")
+    if a.mode == "realtime":
+        embed_realtime(chunks)
+    elif a.mode == "batch":
+        submit_batch(chunks)
+    elif a.mode == "poll":
+        poll_batch(chunks, wait=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/eqc_finish.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+eqc_finish.py — autonomous, resumable finisher.
+
+Loops embedding passes (realtime, gentle) until >=99% of chunks are embedded,
+surviving the fluctuating free-tier quota (sleeps between passes). Then:
+  - load into eqc_qa Qdrant (recreate)
+  - run verification probes
+Everything is resumable; safe to kill and re-launch. Progress -> /tmp/eqc_finish.log
+"""
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+PY = "/Users/dmpantiu/copernicus_mcp/marine_rag/.venv/bin/python"
+CHUNKS = ROOT / "chunks.jsonl"
+EMB = ROOT / "chunks_embedded.jsonl"
+SENTINEL = ROOT / "EMBED_DONE"
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def coverage():
+    total = sum(1 for _ in open(CHUNKS))
+    got = 0
+    if EMB.exists():
+        got = sum(1 for _ in open(EMB))
+    return got, total
+
+
+def main():
+    max_passes = 400
+    for p in range(max_passes):
+        got, total = coverage()
+        log(f"[pass {p}] coverage {got}/{total} = {got/total:.1%}")
+        if got >= total * 0.99:
+            SENTINEL.write_text(f"{got}/{total}\n")
+            log("embeddings complete.")
+            break
+        subprocess.run([PY, str(ROOT / "embed_reports.py")], cwd=str(ROOT))
+        got2, _ = coverage()
+        if got2 <= got:
+            # no progress this pass -> quota drought; back off longer
+            log("no progress; sleeping 180s for quota window")
+            time.sleep(180)
+        else:
+            time.sleep(20)
+    else:
+        log("max passes reached without completion")
+
+    got, total = coverage()
+    if got < total * 0.99:
+        log(f"STOPPING: only {got}/{total} embedded; re-run this script to resume.")
+        return
+
+    log("=== loading Qdrant ===")
+    subprocess.run([PY, str(ROOT / "load_eqc_qa.py"), "--recreate"], cwd=str(ROOT))
+    log("=== verifying ===")
+    subprocess.run([PY, str(ROOT / "verify_eqc_qa.py")], cwd=str(ROOT))
+    log("=== eqc_finish DONE ===")
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/eqc_orchestrator.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Resumable batch orchestrator for EQC QA embeddings.
+Retries batch submit through quota 429s (long backoff), then polls the job to
+completion, downloads embeddings -> chunks_embedded.jsonl, writes EMBED_DONE.
+Resumable: reuses batch_job.txt if a job was already submitted.
+"""
+import json, sys, time
+from pathlib import Path
+sys.path.insert(0, "/Users/dmpantiu/copernicus_mcp/marine_rag")
+sys.path.insert(0, "/Users/dmpantiu/copernicus_mcp/eqc_qa")
+import net_ipv4  # noqa
+from embed_reports import (get_client, MODEL, BATCH_INPUT, JOB_FILE, OUT, SENTINEL,
+                           load_chunks, embedded_keys, _extract_values, l2, finalize)
+
+def log(*a): print(*a, file=sys.stderr, flush=True)
+
+def submit():
+    delay = 30
+    for attempt in range(240):  # ~ up to a few hours
+        try:
+            c = get_client()
+            up = c.files.upload(file=str(BATCH_INPUT),
+                                config={"display_name": "eqc_qa_embed", "mime_type": "jsonl"})
+            job = c.batches.create_embeddings(model=MODEL, src={"file_name": up.name},
+                                              config={"display_name": "eqc_qa_embeddings"})
+            JOB_FILE.write_text(job.name)
+            log(f"SUBMITTED {job.name} {job.state}")
+            return job.name
+        except Exception as e:
+            es = str(e)[:90]
+            log(f"submit attempt {attempt}: {es}")
+            time.sleep(delay)
+            delay = min(delay * 1.3, 120)
+    raise SystemExit("submit failed after many attempts")
+
+def main():
+    chunks = load_chunks()
+    if JOB_FILE.exists() and JOB_FILE.read_text().strip():
+        name = JOB_FILE.read_text().strip()
+        log(f"resuming existing job {name}")
+    else:
+        name = submit()
+    c = get_client()
+    while True:
+        try:
+            job = c.batches.get(name=name)
+        except Exception as e:
+            log(f"poll err {str(e)[:80]}"); time.sleep(30); c = get_client(); continue
+        state = str(job.state)
+        log(f"job {name}: {state}")
+        if any(s in state for s in ("SUCCEEDED", "FAILED", "CANCELLED", "EXPIRED")):
+            break
+        time.sleep(30)
+    if "SUCCEEDED" not in state:
+        log(f"job ended {state} — not successful"); sys.exit(1)
+    by_key = {x["chunk_id"]: x for x in chunks}
+    dest = getattr(job, "dest", None)
+    fn = getattr(dest, "file_name", None) if dest else None
+    lines = []
+    if fn:
+        lines = c.files.download(file=fn).decode("utf-8").strip().split("\n")
+    elif dest and getattr(dest, "inlined_responses", None):
+        lines = [json.dumps(r) for r in dest.inlined_responses]
+    n = 0
+    with open(OUT, "a", encoding="utf-8") as fout:
+        for line in lines:
+            if not line.strip(): continue
+            r = json.loads(line)
+            k = r.get("key") or r.get("custom_id")
+            vals = _extract_values(r)
+            if k in by_key and vals:
+                x = dict(by_key[k]); x["embedding"] = l2(vals)
+                fout.write(json.dumps(x, ensure_ascii=False) + "\n"); n += 1
+    log(f"downloaded {n} embeddings -> {OUT}")
+    finalize(chunks)
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/extract_code.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""
+extract_code.py — CODE-PRESERVING re-extraction of the EQC notebooks.
+
+Companion to parse_reports.py (which is text-only and DROPS runnable code).
+This one keeps every code cell verbatim so the notebooks can be ATTACHED to
+RAG chunks (payload riders keyed by dataset_id) — the agent then sees the real
+cdsapi / copernicusmarine / xarray / plot code, not just prose.
+
+Does NOT mutate any Qdrant index and does NOT touch existing parsed/*.md.
+Outputs (all new):
+  eqc_qa/notebooks_code/<report_id>.md      full reconstruction (```python fences)
+  eqc_qa/notebooks_by_dataset.json          dataset_id -> [notebook attach records]
+  eqc_qa/extract_code_stats.json            summary
+
+Mapping reuses eqc_qa/reports.jsonl (matched_dataset_id / store / confidence).
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+REPO = ROOT / "repo"
+MANIFEST = ROOT / "reports.jsonl"
+OUT_MD = ROOT / "notebooks_code"
+OUT_SIDECAR = ROOT / "notebooks_by_dataset.json"
+OUT_STATS = ROOT / "extract_code_stats.json"
+
+SOURCE_REPO = "ecmwf-projects/c3s2-eqc-quality-assessment"
+LICENSE = "Apache-2.0"
+
+DOWNLOAD_RE = re.compile(
+    r"cdsapi|\.retrieve\(|copernicusmarine|\bcm\.(subset|get|open_dataset)|"
+    r"c3s_eqc_automatic_quality_control|\bdownload\.|from .*import .*download|"
+    r"!?\bwget\b|urlretrieve|requests\.get|\.hda\b|EO:",
+    re.I,
+)
+ANALYZE_RE = re.compile(
+    r"\bimport xarray|\bxr\.|\.open_dataset|\.open_mfdataset|\bimport pandas|\bpd\.|"
+    r"\bimport numpy|\bnp\.|\bscipy|\bxskillscore|\bruptures|\.groupby\(|\.resample\(|"
+    r"\.mean\(|\.sel\(|\.isel\(",
+    re.I,
+)
+PLOT_RE = re.compile(
+    r"\bmatplotlib|\bplt\.|\bcartopy|\bccrs\b|\bcmocean|\.plot\(|\.plot\.|seaborn|\bsns\.",
+    re.I,
+)
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def _src(cell) -> str:
+    s = cell.get("source", "")
+    return "".join(s) if isinstance(s, list) else s
+
+
+def code_line_count(code: str) -> int:
+    n = 0
+    for ln in code.splitlines():
+        st = ln.strip()
+        if st and not st.startswith("#"):
+            n += 1
+    return n
+
+
+def text_outputs(cell) -> list[str]:
+    """Trimmed text outputs (stdout/stderr/text-plain), dropping progress-bar / warning noise."""
+    out = []
+    for o in cell.get("outputs", []):
+        ot = o.get("output_type")
+        s = None
+        if ot == "stream":
+            t = o.get("text", "")
+            s = "".join(t) if isinstance(t, list) else t
+        elif ot in ("execute_result", "display_data"):
+            tp = (o.get("data") or {}).get("text/plain")
+            if tp is not None:
+                s = "".join(tp) if isinstance(tp, list) else tp
+        if not s:
+            continue
+        s = s.strip()
+        if not s or re.fullmatch(r"<[^>]+>", s) or s.startswith("<Figure"):
+            continue
+        # drop tqdm-style progress bars and pure warning spew
+        lines = [ln for ln in s.splitlines()
+                 if "%|" not in ln and "it/s]" not in ln and "B/s]" not in ln]
+        s = "\n".join(lines).strip()
+        if len(s) >= 8:
+            out.append(s[:1500])  # cap giant dumps
+    return out
+
+
+def classify(code: str) -> list[str]:
+    kinds = []
+    if DOWNLOAD_RE.search(code):
+        kinds.append("download")
+    if ANALYZE_RE.search(code):
+        kinds.append("analyze")
+    if PLOT_RE.search(code):
+        kinds.append("plot")
+    return kinds or ["other"]
+
+
+def extract_notebook(path: Path) -> dict:
+    nb = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    parts = []          # reconstructed md
+    n_code_cells = 0
+    n_code_lines = 0
+    kinds = set()
+    title = ""
+    for cell in nb.get("cells", []):
+        ct = cell.get("cell_type")
+        if ct == "markdown":
+            txt = _src(cell).strip()
+            if txt:
+                parts.append(txt)
+                if not title:
+                    for ln in txt.splitlines():
+                        if ln.startswith("# "):
+                            title = ln[2:].strip()
+                            break
+        elif ct == "code":
+            src = _src(cell).rstrip()
+            if not src.strip():
+                continue
+            n_code_cells += 1
+            n_code_lines += code_line_count(src)
+            kinds.update(classify(src))
+            parts.append("```python\n" + src + "\n```")
+            for to in text_outputs(cell):
+                parts.append("```text\n" + to + "\n```")
+    return {
+        "content_md": "\n\n".join(parts).strip(),
+        "title": title or path.stem,
+        "n_code_cells": n_code_cells,
+        "n_code_lines": n_code_lines,
+        "recipe_kinds": sorted(kinds),
+    }
+
+
+def main():
+    OUT_MD.mkdir(exist_ok=True)
+    manifest = {r["report_id"]: r for r in
+                (json.loads(l) for l in MANIFEST.read_text().splitlines() if l.strip())}
+    log(f"manifest: {len(manifest)} reports")
+
+    sidecar: dict[str, list] = {}
+    unmatched: list = []
+    stats = {"notebooks": 0, "code_cells": 0, "code_lines": 0,
+             "with_download": 0, "with_analyze": 0, "with_plot": 0,
+             "attached_datasets": 0, "unmatched_notebooks": 0}
+
+    for nb in sorted(REPO.rglob("*.ipynb")):
+        report_id = nb.stem
+        rec = manifest.get(report_id, {})
+        ex = extract_notebook(nb)
+        if ex["n_code_cells"] == 0:
+            continue  # prose-only (e.g. Applications write-ups) — nothing to attach
+        # write full reconstruction
+        (OUT_MD / f"{report_id}.md").write_text(ex["content_md"], encoding="utf-8")
+
+        attach = {
+            "notebook_id": report_id,
+            "title": ex["title"],
+            "store": rec.get("store") or "CDS",
+            "matched_dataset_id": rec.get("matched_dataset_id") or "",
+            "raw_dataset_id": rec.get("dataset_id") or "",
+            "category": rec.get("category") or "",
+            "aspect": rec.get("aspect") or "",
+            "match_confidence": rec.get("match_confidence") or "unmatched",
+            "source_repo": SOURCE_REPO,
+            "license": LICENSE,
+            "src_path": rec.get("src_path") or str(nb.relative_to(REPO)),
+            "md_path": str((OUT_MD / f"{report_id}.md").relative_to(ROOT.parent)),
+            "n_code_cells": ex["n_code_cells"],
+            "n_code_lines": ex["n_code_lines"],
+            "recipe_kinds": ex["recipe_kinds"],
+        }
+        stats["notebooks"] += 1
+        stats["code_cells"] += ex["n_code_cells"]
+        stats["code_lines"] += ex["n_code_lines"]
+        stats["with_download"] += "download" in ex["recipe_kinds"]
+        stats["with_analyze"] += "analyze" in ex["recipe_kinds"]
+        stats["with_plot"] += "plot" in ex["recipe_kinds"]
+
+        key = attach["matched_dataset_id"]
+        if key:
+            sidecar.setdefault(key, []).append(attach)
+        else:
+            unmatched.append(attach)
+            stats["unmatched_notebooks"] += 1
+
+    stats["attached_datasets"] = len(sidecar)
+    OUT_SIDECAR.write_text(json.dumps(
+        {"by_dataset": sidecar, "unmatched": unmatched}, ensure_ascii=False, indent=2))
+    OUT_STATS.write_text(json.dumps(stats, indent=2))
+
+    log(f"notebooks with code : {stats['notebooks']}")
+    log(f"code cells / lines   : {stats['code_cells']} / {stats['code_lines']:,}")
+    log(f"download/analyze/plot: {stats['with_download']}/{stats['with_analyze']}/{stats['with_plot']}")
+    log(f"attached to datasets : {stats['attached_datasets']} (unmatched notebooks: {stats['unmatched_notebooks']})")
+    log(f"-> {OUT_SIDECAR.relative_to(ROOT.parent)}, {OUT_MD.relative_to(ROOT.parent)}/*.md")
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/fetch_reports.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+fetch_reports.py — obtain the C3S EQC Quality Assessment notebooks.
+
+Source: public GitHub repo ecmwf-projects/c3s2-eqc-quality-assessment (74 .ipynb).
+Strategy: shallow git clone into eqc_qa/repo (idempotent — re-fetches if missing).
+Then list every notebook with its top-level category dir + filename.
+
+Text only; no rendering. stderr logging.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+REPO = ROOT / "repo"
+URL = "https://github.com/ecmwf-projects/c3s2-eqc-quality-assessment"
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def ensure_repo() -> None:
+    if (REPO / ".git").exists():
+        log(f"repo already present: {REPO}")
+        return
+    log(f"cloning {URL} --depth 1 -> {REPO}")
+    subprocess.run(
+        ["git", "clone", "--depth", "1", URL, str(REPO)],
+        check=True,
+    )
+
+
+def list_notebooks() -> list[Path]:
+    return sorted(REPO.rglob("*.ipynb"))
+
+
+def main() -> None:
+    ensure_repo()
+    nbs = list_notebooks()
+    log(f"found {len(nbs)} notebooks")
+    from collections import Counter
+    cats = Counter(nb.relative_to(REPO).parts[0] for nb in nbs)
+    for nb in nbs:
+        rel = nb.relative_to(REPO)
+        print(f"{rel.parts[0]}\t{nb.name}")
+    log("category counts: " + ", ".join(f"{k}={v}" for k, v in sorted(cats.items())))
+    log(f"TOTAL {len(nbs)} notebooks")
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/load_eqc_qa.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+load_eqc_qa.py — load embedded EQC QA chunks into a SEPARATE embedded Qdrant.
+
+Mirrors marine_rag/load_qdrant.py. Collection `eqc_qa`:
+  - dense  (768-dim, Cosine) gemini-embedding-2-preview
+  - sparse (BM25 via FastEmbed, IDF modifier)
+  - payload indexes: dataset_id, store, doc_type, aspect
+
+Storage: eqc_qa/qdrant_db  (its OWN db — does NOT touch marine_rag/out/qdrant_db
+or pubs_rag/qdrant_db, to avoid single-process lock contention).
+
+Usage: python load_eqc_qa.py --recreate
+"""
+import argparse
+import json
+import sys
+import time
+import uuid
+from pathlib import Path
+
+from qdrant_client import QdrantClient, models
+from fastembed import SparseTextEmbedding
+
+ROOT = Path(__file__).resolve().parent
+COLLECTION = "eqc_qa"
+DENSE_DIM = 768
+INPUT = ROOT / "chunks_embedded.jsonl"
+LOCAL_DB = ROOT / "qdrant_db"
+BATCH = 256
+
+_bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def to_sparse(text: str) -> models.SparseVector:
+    r = list(_bm25.embed([text]))[0]
+    return models.SparseVector(indices=r.indices.tolist(), values=r.values.tolist())
+
+
+def create_collection(client: QdrantClient, recreate: bool) -> None:
+    names = [c.name for c in client.get_collections().collections]
+    if COLLECTION in names:
+        if recreate:
+            client.delete_collection(COLLECTION)
+        else:
+            log(f"'{COLLECTION}' exists: {client.get_collection(COLLECTION).points_count} pts")
+            return
+    client.create_collection(
+        collection_name=COLLECTION,
+        vectors_config={"dense": models.VectorParams(size=DENSE_DIM, distance=models.Distance.COSINE)},
+        sparse_vectors_config={"sparse": models.SparseVectorParams(modifier=models.Modifier.IDF)},
+    )
+    for field in ("dataset_id", "store", "doc_type", "aspect"):
+        client.create_payload_index(collection_name=COLLECTION, field_name=field,
+                                    field_schema=models.PayloadSchemaType.KEYWORD)
+    log(f"created '{COLLECTION}' (dense+sparse, 4 payload indexes)")
+
+
+def load(client: QdrantClient) -> None:
+    buf, total, skipped, t0 = [], 0, 0, time.time()
+    with open(INPUT, encoding="utf-8") as f:
+        for line in f:
+            c = json.loads(line)
+            emb = c.get("embedding")
+            if not emb:
+                skipped += 1
+                continue
+            raw = c.get("text_raw", "")
+            buf.append(models.PointStruct(
+                id=str(uuid.uuid5(uuid.NAMESPACE_DNS, c["chunk_id"])),
+                vector={"dense": emb, "sparse": to_sparse(raw)},
+                payload={
+                    "chunk_id": c["chunk_id"],
+                    "report_id": c["report_id"],
+                    "dataset_id": c["dataset_id"],
+                    "store": c["store"],
+                    "doc_type": c["doc_type"],
+                    "aspect": c["aspect"],
+                    "aspect_base": c.get("aspect_base", ""),
+                    "category": c.get("category", ""),
+                    "match_confidence": c.get("match_confidence", ""),
+                    "section": c.get("section", ""),
+                    "title": c.get("title", ""),
+                    "text_raw": raw[:2500],
+                },
+            ))
+            if len(buf) >= BATCH:
+                client.upsert(collection_name=COLLECTION, points=buf)
+                total += len(buf)
+                log(f"  [{total}] {total/(time.time()-t0):.0f} pts/s")
+                buf = []
+    if buf:
+        client.upsert(collection_name=COLLECTION, points=buf)
+        total += len(buf)
+    log(f"DONE: {total} points, skipped {skipped}, total now "
+        f"{client.get_collection(COLLECTION).points_count}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--recreate", action="store_true")
+    a = ap.parse_args()
+    client = QdrantClient(path=str(LOCAL_DB))
+    log(f"Qdrant local: {LOCAL_DB}")
+    create_collection(client, a.recreate)
+    load(client)
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/merge_notebooks.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+merge_notebooks.py — unify the notebook code layer into ONE sidecar the server reads.
+
+Inputs (both read-only, never mutated):
+  eqc_qa/eqc_notebooks_by_dataset.json     EQC-only base (from extract_code.py)
+  notebook_harvest/harvest_records.json    list of per-repo results from the harvest
+                                           workflow (each: {repo, license, records:[...]})
+
+Output:
+  eqc_qa/notebooks_by_dataset.json         unified: by_dataset + generic_by_store + sources
+
+Record shape stored per notebook:
+  notebook_id, title, store, matched_dataset_id, source_repo, license,
+  src_path, md_path, n_code_cells, n_code_lines, recipe_kinds, scope
+"""
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+EQC_BASE = ROOT / "eqc_qa" / "eqc_notebooks_by_dataset.json"
+HARVEST = ROOT / "notebook_harvest" / "harvest_records.json"
+OUT = ROOT / "eqc_qa" / "notebooks_by_dataset.json"
+
+STORE_SPLIT = {"CDS/ADS/EWDS": ["CDS", "ADS", "EWDS"], "CADS": ["CDS", "ADS", "EWDS"]}
+# normalise the free-text store labels agents produced to the 4 canonical stores
+STORE_NORM = {
+    "CMEMS IN-SITU": "CMEMS", "CMEMS INSITU": "CMEMS", "MARINE": "CMEMS",
+    "EWDS/CEMS": "EWDS", "CEMS": "EWDS", "CEMS/EWDS": "EWDS",
+    "C3S": "CDS", "CAMS": "ADS", "ADS/CAMS": "ADS",
+}
+
+
+def _store(raw: str) -> str:
+    s = (raw or "").strip()
+    return STORE_NORM.get(s.upper(), s)
+
+
+def _norm(rec: dict, dataset_id: str, scope: str) -> dict:
+    return {
+        "notebook_id": rec.get("notebook_id"),
+        "title": rec.get("title"),
+        "store": _store(rec.get("store")),
+        "matched_dataset_id": dataset_id,
+        "source_repo": rec.get("source_repo") or rec.get("repo") or "",
+        "license": rec.get("license") or "",
+        "src_path": rec.get("src_path") or "",
+        "md_path": rec.get("md_path") or "",
+        "n_code_cells": rec.get("n_code_cells") or 0,
+        "n_code_lines": rec.get("n_code_lines") or 0,
+        "recipe_kinds": rec.get("recipe_kinds") or [],
+        "scope": scope,
+    }
+
+
+def main():
+    by_dataset: dict[str, list] = {}
+    generic: dict[str, list] = {}
+    sources: dict[str, dict] = {}
+    seen: set = set()  # (notebook_id, dataset_id) dedup
+
+    def add_dataset(dsid, rec):
+        key = (rec["notebook_id"], dsid)
+        if not dsid or key in seen:
+            return
+        seen.add(key)
+        by_dataset.setdefault(dsid, []).append(rec)
+
+    def add_generic(store, rec):
+        key = (rec["notebook_id"], f"__generic__{store}")
+        if key in seen:
+            return
+        seen.add(key)
+        generic.setdefault(store, []).append(rec)
+
+    # 1) EQC base (all dataset-scoped, store=CDS)
+    base = json.loads(EQC_BASE.read_text())
+    for dsid, recs in base.get("by_dataset", {}).items():
+        for r in recs:
+            add_dataset(dsid, _norm(r, dsid, "dataset"))
+    sources["ecmwf-projects/c3s2-eqc-quality-assessment"] = {
+        "license": "Apache-2.0",
+        "n_notebooks": sum(len(v) for v in base.get("by_dataset", {}).values()),
+    }
+
+    # 2) harvested repos
+    if HARVEST.exists():
+        harvest = json.loads(HARVEST.read_text())
+        for repo in harvest:
+            if not repo:
+                continue
+            sources[repo.get("repo", "?")] = {
+                "license": repo.get("license"),
+                "status": repo.get("status"),
+                "n_notebooks": repo.get("n_notebooks"),
+                "n_code_lines": repo.get("n_code_lines"),
+            }
+            for r in repo.get("records", []):
+                scope = r.get("scope", "dataset")
+                if scope == "dataset" and r.get("matched_dataset_ids"):
+                    for dsid in r["matched_dataset_ids"]:
+                        add_dataset(dsid, _norm(r, dsid, "dataset"))
+                else:
+                    raw = (r.get("store") or "").strip()
+                    stores = STORE_SPLIT.get(raw) or STORE_SPLIT.get(raw.upper()) \
+                        or [_store(raw)] if raw else ["UNKNOWN"]
+                    for s in stores:
+                        add_generic(s, _norm(r, "", "generic"))
+
+    out = {"by_dataset": by_dataset, "generic_by_store": generic, "sources": sources}
+    OUT.write_text(json.dumps(out, ensure_ascii=False, indent=1))
+
+    n_ds_nb = sum(len(v) for v in by_dataset.values())
+    n_gen = sum(len(v) for v in generic.values())
+    print(json.dumps({
+        "datasets_with_notebooks": len(by_dataset),
+        "dataset_notebook_records": n_ds_nb,
+        "generic_stores": {k: len(v) for k, v in generic.items()},
+        "generic_records": n_gen,
+        "sources": len(sources),
+        "out": str(OUT.relative_to(ROOT)),
+    }, indent=1))
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/parse_reports.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+parse_reports.py — extract TEXT only from each EQC QA notebook.
+
+For every repo/**/*.ipynb (parsed as JSON, no nbformat dependency):
+  - markdown cells  -> kept verbatim (prose: methodology, findings, verdicts;
+                       headings preserved for section-aware chunking)
+  - code cells      -> comment lines from source (prose intent) + TEXT outputs
+                       (stream stdout/stderr, execute_result/display_data
+                        'text/plain'). SKIP image/png/jpeg/svg/base64/raw data.
+
+Filename encodes dataset + report type:
+  <prefix>_<dataset_id>_<aspect>_q<NN>.ipynb
+  e.g. satellite_satellite-sea-surface-temperature_consistency_q01
+       -> dataset=satellite-sea-surface-temperature aspect=consistency q=q01
+
+Dataset mapping: cross-reference dataset_id against the CDS/ADS/EWDS catalogue
+(meta_harvest/{cds,ads,ewds}_enriched.json); exact -> fuzzy substring -> unmatched.
+
+Outputs:
+  eqc_qa/parsed/<report_id>.md
+  eqc_qa/reports.jsonl  (manifest, one line per report)
+
+templates/template.ipynb is a scaffold (not a dataset report): parsed for text
+but flagged is_template and left dataset-unmatched.
+"""
+import json
+import sys
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+REPO = ROOT / "repo"
+PARSED = ROOT / "parsed"
+MANIFEST = ROOT / "reports.jsonl"
+META = ROOT.parent / "meta_harvest"
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+# ── catalogue for dataset mapping ────────────────────────────────────────────
+def load_catalogue() -> dict[str, str]:
+    ids: dict[str, str] = {}
+    for name, store in (("cds", "CDS"), ("ads", "ADS"), ("ewds", "EWDS")):
+        p = META / f"{name}_enriched.json"
+        if p.exists():
+            for k in json.loads(p.read_text()):
+                ids[k] = store
+    return ids
+
+
+def map_dataset(dataset_id: str, catalogue: dict[str, str]) -> tuple[str, str, str]:
+    """Return (matched_id, store, confidence:{exact,fuzzy,unmatched})."""
+    if not dataset_id:
+        return "", "", "unmatched"
+    if dataset_id in catalogue:
+        return dataset_id, catalogue[dataset_id], "exact"
+    # fuzzy: substring either direction (guard against trivially short ids)
+    if len(dataset_id) >= 5:
+        cands = [k for k in catalogue if dataset_id in k or k in dataset_id]
+        if cands:
+            best = min(cands, key=len)
+            return best, catalogue[best], "fuzzy"
+    return "", "", "unmatched"
+
+
+# ── text extraction ──────────────────────────────────────────────────────────
+def _src(cell) -> str:
+    s = cell.get("source", "")
+    return "".join(s) if isinstance(s, list) else s
+
+
+def comment_lines(code: str) -> list[str]:
+    out = []
+    for ln in code.splitlines():
+        st = ln.strip()
+        if st.startswith("#") and not st.startswith("#!"):
+            txt = st.lstrip("#").strip()
+            if len(txt) >= 12 and not txt.startswith("%"):  # skip trivial / magics
+                out.append(txt)
+    return out
+
+
+def text_outputs(cell) -> list[str]:
+    out = []
+    for o in cell.get("outputs", []):
+        ot = o.get("output_type")
+        if ot == "stream":
+            t = o.get("text", "")
+            out.append("".join(t) if isinstance(t, list) else t)
+        elif ot in ("execute_result", "display_data"):
+            data = o.get("data", {})
+            tp = data.get("text/plain")
+            if tp is not None:
+                # skip pure object reprs like "<Figure ...>" / matplotlib handles
+                s = "".join(tp) if isinstance(tp, list) else tp
+                s = s.strip()
+                if s and not re.fullmatch(r"<[^>]+>", s) and not s.startswith("<Figure"):
+                    out.append(s)
+        # image/png, image/jpeg, image/svg+xml, application/* -> skipped entirely
+    return out
+
+
+def parse_notebook(path: Path) -> tuple[str, str]:
+    """Return (markdown_text, title)."""
+    nb = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    parts: list[str] = []
+    for cell in nb.get("cells", []):
+        ct = cell.get("cell_type")
+        if ct == "markdown":
+            txt = _src(cell).strip()
+            if txt:
+                parts.append(txt)
+        elif ct == "code":
+            src = _src(cell)
+            cmts = comment_lines(src)
+            if cmts:
+                parts.append("\n".join(cmts))
+            for to in text_outputs(cell):
+                to = to.strip()
+                if to and len(to) >= 8:
+                    parts.append("```text\n" + to + "\n```")
+    md = "\n\n".join(parts).strip()
+    # title = first H1
+    title = ""
+    for ln in md.splitlines():
+        if ln.startswith("# "):
+            title = ln[2:].strip()
+            break
+    if not title:
+        title = path.stem
+    return md, title
+
+
+# ── manifest build ───────────────────────────────────────────────────────────
+def main() -> None:
+    PARSED.mkdir(exist_ok=True)
+    catalogue = load_catalogue()
+    log(f"catalogue: {len(catalogue)} collection ids")
+
+    nbs = sorted(REPO.rglob("*.ipynb"))
+    log(f"parsing {len(nbs)} notebooks")
+
+    records = []
+    stats = {"exact": 0, "fuzzy": 0, "unmatched": 0}
+    for nb in nbs:
+        rel = nb.relative_to(REPO)
+        category = rel.parts[0]
+        report_id = nb.stem
+        toks = report_id.split("_")
+        is_template = len(toks) != 4
+        if is_template:
+            dataset_id, aspect_base, qnum = "", "", ""
+        else:
+            _prefix, dataset_id, aspect_base, qnum = toks
+        aspect = f"{aspect_base}_{qnum}" if aspect_base else ""
+
+        matched_id, store, conf = map_dataset(dataset_id, catalogue)
+        if is_template:
+            conf = "unmatched"
+        stats[conf] += 1
+
+        md, title = parse_notebook(nb)
+        md_path = PARSED / f"{report_id}.md"
+        md_path.write_text(md, encoding="utf-8")
+
+        rec = {
+            "report_id": report_id,
+            "dataset_id": dataset_id,
+            "matched_dataset_id": matched_id,
+            "store": store,
+            "match_confidence": conf,
+            "category": category,
+            "aspect": aspect,
+            "aspect_base": aspect_base,
+            "qnum": qnum,
+            "title": title,
+            "md_path": str(md_path.relative_to(ROOT)),
+            "n_chars": len(md),
+            "is_template": is_template,
+            "src_path": str(rel),
+        }
+        records.append(rec)
+
+    with open(MANIFEST, "w", encoding="utf-8") as f:
+        for r in records:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    reports = [r for r in records if not r["is_template"]]
+    log(f"wrote {len(records)} manifest rows ({len(reports)} reports + "
+        f"{len(records)-len(reports)} template) -> {MANIFEST}")
+    log(f"mapping: exact={stats['exact']} fuzzy={stats['fuzzy']} unmatched={stats['unmatched']}")
+    ndatasets = len({r['matched_dataset_id'] for r in reports if r['match_confidence'] != 'unmatched'})
+    log(f"reports mapped to a known collection: "
+        f"{sum(1 for r in reports if r['match_confidence']!='unmatched')}/{len(reports)} "
+        f"across {ndatasets} unique collections")
+    log(f"total chars: {sum(r['n_chars'] for r in records):,}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eqc_qa/verify_eqc_qa.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+verify_eqc_qa.py — sanity-check the eqc_qa Qdrant collection.
+
+  - point count == embedded chunk count
+  - BM25 (sparse-only) probes  [always works, no API]
+  - hybrid dense+BM25 RRF probes [needs one query embedding per probe; degrades
+    to BM25-only if the Gemini quota 429s]
+
+Probes: SST consistency, satellite soil moisture completeness, multi-origin atlas.
+Prints top hits with report_id + dataset_id.
+"""
+import json
+import sys
+import threading
+from pathlib import Path
+
+sys.path.insert(0, "/Users/dmpantiu/copernicus_mcp/marine_rag")
+import net_ipv4  # noqa: F401,E402
+
+from qdrant_client import QdrantClient, models
+from fastembed import SparseTextEmbedding
+
+ROOT = Path(__file__).resolve().parent
+COLLECTION = "eqc_qa"
+DENSE_DIM = 768
+LOCAL_DB = ROOT / "qdrant_db"
+INPUT = ROOT / "chunks_embedded.jsonl"
+
+_bm25 = None
+_lock = threading.Lock()
+
+
+def log(*a):
+    print(*a, file=sys.stderr, flush=True)
+
+
+def resolve_key() -> str:
+    import os
+    for var in ("GOOGLE_API_KEY", "GEMINI_API_KEY"):
+        if os.environ.get(var):
+            return os.environ[var]
+    for env in (Path("/Users/dmpantiu/copernicus_mcp/.env"),):
+        if env.exists():
+            for line in env.read_text().splitlines():
+                line = line.strip()
+                if "api_key" in line.lower() and "=" in line and not line.startswith("#"):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("no key")
+
+
+def embed_query(q: str):
+    from google import genai
+    from google.genai import types
+    import numpy as np
+    client = genai.Client(api_key=resolve_key())
+    r = client.models.embed_content(
+        model="gemini-embedding-2-preview", contents=q,
+        config=types.EmbedContentConfig(task_type="RETRIEVAL_QUERY", output_dimensionality=DENSE_DIM))
+    v = np.array(list(r.embeddings[0].values), dtype=np.float32)
+    n = np.linalg.norm(v)
+    return (v / n).tolist() if n > 0 else v.tolist()
+
+
+def sparse_query(q: str):
+    global _bm25
+    with _lock:
+        if _bm25 is None:
+            _bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+    sp = list(_bm25.query_embed(q))[0]
+    return models.SparseVector(indices=sp.indices.tolist(), values=sp.values.tolist())
+
+
+def search(client, query, top_k=5):
+    sparse = sparse_query(query)
+    dense = None
+    try:
+        dense = embed_query(query)
+    except Exception as e:
+        log(f"  [dense unavailable: {str(e)[:70]}] BM25-only")
+    if dense is not None:
+        res = client.query_points(
+            collection_name=COLLECTION,
+            prefetch=[
+                models.Prefetch(query=dense, using="dense", limit=50),
+                models.Prefetch(query=sparse, using="sparse", limit=50),
+            ],
+            query=models.FusionQuery(fusion=models.Fusion.RRF),
+            limit=top_k, with_payload=True,
+        )
+        mode = "hybrid dense+BM25 RRF"
+    else:
+        res = client.query_points(collection_name=COLLECTION, query=sparse,
+                                  using="sparse", limit=top_k, with_payload=True)
+        mode = "BM25-only"
+    return res.points, mode
+
+
+def main():
+    client = QdrantClient(path=str(LOCAL_DB))
+    n_pts = client.get_collection(COLLECTION).points_count
+    n_emb = sum(1 for _ in open(INPUT)) if INPUT.exists() else 0
+    print(f"points={n_pts}  embedded_chunks={n_emb}  match={'OK' if n_pts == n_emb else 'MISMATCH'}")
+
+    probes = [
+        "sea surface temperature consistency assessment",
+        "completeness of satellite soil moisture",
+        "multi-origin atlas quality",
+    ]
+    for q in probes:
+        pts, mode = search(client, q, top_k=5)
+        print(f"\n=== '{q}'  [{mode}] ===")
+        for i, p in enumerate(pts, 1):
+            pl = p.payload
+            print(f"  #{i} score={p.score:.4f} report={pl['report_id']}")
+            print(f"      dataset={pl['dataset_id']} aspect={pl['aspect']} "
+                  f"conf={pl.get('match_confidence','')} sec='{pl.get('section','')[:50]}'")
+            print(f"      {pl.get('text_raw','')[:150].strip()}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/MCP_INTEGRATION.md

@@ -0,0 +1,39 @@
+# Phase E — wiring the docs RAG into the MCP server
+
+Goal: a tool the agent calls **through MCP** that, given a dataset/product, returns its
+documentation so the agent knows how to analyze it (find dataset → read docs → work).
+
+## New tool: `marine_dataset_docs`
+
+```
+marine_dataset_docs(dataset_or_product_id: str, question: str | None = None, top_k: int = 8)
+  -> { product_id, product_title, doc_types_available, results: [{doc_type, section, text, score}] }
+```
+
+- Resolves a dataset_id OR product_id → product (via the bundled catalogue), then semantic-searches
+  that product's PUM/QUID/SQO chunks in Qdrant. `question=None` returns the "how to analyze"
+  essentials (variables, coverage, accuracy, validation, interpretation).
+- Backed by `rag_api.get_dataset_docs()` (this folder). Embeddings: `gemini-embedding-2-preview`;
+  retrieval: Qdrant dense+BM25; optional rerank: Google `semantic-ranker-default@latest`.
+
+## Drop-in flow (respect copernicus-mcp conventions: Pydantic I/O, error classes, stderr logging,
+## **no raw bytes** — this returns text/descriptors only, which complies)
+
+1. Package the RAG assets into the server:
+   - ship `out/catalog.json` and the Qdrant store (or point the server at a Qdrant URL).
+   - add deps: `qdrant-client`, `fastembed`, `google-genai`, `numpy`.
+2. Add `src/copernicus_mcp/backends/cmems/docs_rag.py` ≈ a cleaned port of `rag_api.py` + `search.py`
+   (lazy singletons for the Qdrant client, BM25, genai client; key from config/env not a sibling repo).
+3. Register `marine_dataset_docs` in the CMEMS tool module next to `marine_describe_dataset`, with a
+   Pydantic request/response model and one of the canonical error classes for unknown ids /
+   index-unavailable.
+4. TDD + dual adversarial review per the repo's review protocol before merge.
+
+## Intended agent UX
+`marine_search_datasets` → pick dataset → **`marine_dataset_docs(dataset_id)`** → read returned
+sections → run `marine_subset_dataset` with correct, well-understood parameters.
+
+## Status
+- `rag_api.py` works once `out/qdrant_db` is built (after embedding completes). Verify:
+  `python rag_api.py MEDSEA_ANALYSISFORECAST_PHY_006_013 --query "salinity validation accuracy"`
+- Reranker needs GCP ADC + `GCP_PROJECT`; without it, dense+BM25 RRF is used (still good).

scripts/marine_rag/PLAN.md

@@ -0,0 +1,177 @@
+# Marine Docs RAG — Work Plan
+
+## ✅✅ READY (2026-06-25 13:36) — RAG COMPLETE at ~100%
+- Embedded **29,249 / 29,353 unique chunks (99.6%)**; Qdrant `marine_docs` index = **29,249 points**.
+- Verified retrieval across all levels: product docs (QUID/PUM/SQO) AND dataset CARDs + product DESCs.
+- The last shards finished after cancel+resubmit; ~104 chunks (0.4%) dropped — negligible.
+- Background loop stopped; supervision cron ended.
+- NEXT (design done, see out/design.html): code-aware re-chunk of the 344 code docs (attach
+  code_blocks[] to text chunks) + two-stage/parallel search (L0 cards → L1 docs ‖ global, RRF+rerank)
+  + wire marine_dataset_docs into the MCP server.
+
+### (historical) READY at 90% (2026-06-25 02:56)
+- Embedded **26,496 / 29,353 unique chunks (90%)**; Qdrant `marine_docs` index = **26,496 points**.
+- Retrieval VERIFIED: product-doc query (salinity validation → QUID accuracy/Salinity + SQO) and
+  dataset CARD (antarctic_omi_si_extent → PUM/QUID) both return correct sections.
+- Why 90% not 100%: Google free/paid batch queue wedged on the final ~2,857 chunks (jobs sat 3h+
+  with no progress, twice — cancelled & resubmitted, still slow). Not a code issue.
+- **To top up to ~100% later** (no babysitting): `python batch_orchestrator.py` (downloads any
+  shards that finished, resubmits the rest), repeat until `wc -l out/chunks_embedded.jsonl` unique
+  ≈29353, then `python load_qdrant.py --recreate`. Or enable a higher Vertex per-model quota.
+- Background loop stopped; out/EMBEDDING_DONE written.
+
+---
+
+
+## Vision / spec (from user, 2026-06-22 night — verbatim intent)
+
+Build a **RAG for the copernicus-mcp MCP server**, embeddings on **Gemini Embedding 2**
+(`gemini-embedding-2-preview`) + **Google reranker** — no other models. Mirror exactly how it
+was done in `/Users/dmpantiu/cmip6/cmip6_gpt/` (study that folder + its article/PLAN: how the
+Qdrant collection was created, how chunks were cleaned/grouped, BM25, etc.) and do the **same**
+for this MCP server, but **per dataset**.
+
+- Dataset search already exists in the server. **Now each dataset must also carry documentation**
+  (the marine_parsed descriptions, quality-assurance docs, etc.) so the agent can: find a dataset →
+  read its docs → know how to analyze it.
+- The RAG lives **inside the MCP server** and is reachable **through MCP**: add a tool (a kind of
+  "clarification" tool) the agent/MCP calls; it queries this RAG and returns the documentation
+  info for a dataset. "RAG pulls through MCP."
+- Chunks must be properly split (BM25 + dense), same approach as the cmip6 article/pipeline.
+- Catalog + a clean descending **tree of all Copernicus products/datasets**; doc tree too.
+- Marine docs already provide `.md`; **images are NOT embedded — md text only**.
+- More docs arrive tomorrow (resumable re-run picks them up).
+- **BUDGET CAP: spend ≤ €50 on the embedding API.** (Current estimate ~$2 for all 22,556 chunks —
+  far under cap; embedding is cheap, no risk.)
+- Work autonomously overnight via a 10-min self-check loop; do not wake the user.
+
+
+
+**Goal.** Give every Copernicus Marine dataset/product attached, searchable documentation
+(PUM / QUID / SQO) so the agent can: find a dataset → read its docs → know how to analyze it.
+Plus a clean top-down tree of the whole Copernicus Marine catalogue.
+
+**Models (locked by user — no substitutes):**
+- Embeddings: **`gemini-embedding-2-preview`** (Vertex / Google GenAI), 768-dim, L2-normalized, task `RETRIEVAL_DOCUMENT`.
+- Reranker: **Google Vertex AI Rank API** `semantic-ranker-default@latest` (NOT an LLM).
+- Vector store: Qdrant (dense Gemini + sparse BM25 hybrid), mirrors `cmip6_gpt/rag`.
+
+**Reused pipeline:** `/Users/dmpantiu/cmip6/cmip6_gpt/rag/` — `chunk_papers.py` (`chunk_markdown_document`),
+`embed_and_index.py`, `load_qdrant.py`, `search.py`. Deps already in `cmip6_gpt/.venv`.
+
+---
+
+## Source data
+
+- `marine_parsed/<PRODUCT_ID>/<DOC_ID>/<DOC_ID>/vlm/<DOC_ID>.md` — VLM-parsed docs.
+- 309 product folders; **306 match `products.json` product_ids 1:1 (100% catalogue coverage)**, 3 extra.
+- Doc types: **QUID** (308), **PUM** (283), **SQO** (196), + OC-PUM. Total **813 `.md`** files.
+- ~37k images present but **NOT used** (embeddings are text-only, per user).
+- Catalogue manifests: `copernicus-mcp-dev/src/copernicus_mcp/backends/cmems/_data/`
+  (`products.json` 306, `dataset_cards.json` 1251, `groups.json` 47 routing groups, `marine.json`, `variables_lookup.json`).
+
+---
+
+## Phases
+
+### Phase A — Catalog + Tree (NO API) ✅ doable now
+- A1. `build_catalog.py` → `out/catalog.json`: map every product_id → {title, group, datasets, doc files (PUM/QUID/SQO) with md paths, sizes}. Flag products missing docs and docs missing products.
+- A2. `build_tree.py` → `out/tree.txt` + `out/tree.md`: descending tree
+  Catalogue → routing group → product → datasets, with doc-coverage badges.
+
+### Phase B — Chunking (NO API) ✅ doable now
+- B1. `chunk_docs.py`: adapt `chunk_markdown_document` for marine docs. Prefix carries
+  product_id, product_title, doc_type (PUM/QUID/SQO), section path. Images stripped.
+  Reuse all noise/OCR/dedup filters. Resumable.
+- B2. Run on all 813 md → `out/chunks.jsonl`. Record per-doc chunk counts + token totals.
+
+### Phase C — Embedding (NEEDS API) ⛔ BLOCKED: Gemini key IP-restricted
+- BLOCKER: key `AQ.Ab8…` rejects IP `134.1.1.80` (403). Fix: whitelist this IP in Google
+  Cloud Console, or remove the IP restriction on the key.
+- C1. `embed.py` (adapted from `embed_and_index.py`): `gemini-embedding-2-preview`, 768-dim,
+  realtime + batch modes, resumable → `out/chunks_embedded.jsonl`.
+- C2. Cost estimate emitted before run.
+
+### Phase D — Index + Search (NEEDS API + Qdrant) ⛔ after C
+- D1. `load_qdrant.py`: local Qdrant (embedded path mode) collection `marine_docs`,
+  dense Gemini + BM25 sparse.
+- D2. `search.py`: hybrid retrieve → `semantic-ranker-default@latest` rerank → top-k.
+
+### Phase E — MCP integration ⛔ after D
+- E1. New tool `marine_read_docs(dataset_or_product_id)` → returns relevant doc chunks
+  (filepath + cited sections), so the agent reads docs before analyzing.
+- E2. Optional `marine_search_docs(query)` semantic search across all docs.
+- Follow copernicus-mcp invariants (no raw bytes, descriptor returns, stderr logging).
+
+---
+
+## Status log
+- 2026-06-22: workspace created; key validated (auth OK) but IP-restricted; deps confirmed in cmip6 venv.
+- 2026-06-22: Phase A DONE — `out/catalog.json` (306 products, 100% doc coverage), `out/tree.txt`,
+  `out/tree_by_region.txt`, `out/tree.md`.
+- 2026-06-22: Phase B DONE — `out/chunks.jsonl`: 813 docs → 22,556 chunks, 8.46M tokens
+  (embed cost ~$2 realtime / ~$1 batch).
+- 2026-06-22: Phase C/D scripts written (`embed.py`, `load_qdrant.py`, `search.py`). BLOCKED on key IP whitelist.
+- 2026-06-22: `run_overnight.sh` launched in background (retry every 10 min) — auto-finishes C+D when IP unblocks.
+- 2026-06-23 00:30: Gemini key IP restriction RESOLVED (user removed it). Key works (dims=768).
+- 2026-06-23 00:40: discovered real constraint = **~5 RPM quota** on the AQ express key
+  (429 RESOURCE_EXHAUSTED). embed.py tuned: batch=100, ~13s spacing, 35s backoff on 429.
+- 2026-06-23 01:00: **Phase B.5 CLEANING added (user: "чистка вначале!")** — mirrors cmip6 preprocess:
+  `clean_md.py` strips CMEMS boilerplate (CHANGE RECORD, TOC, ACRONYM TABLE, running headers,
+  REFERENCES), converts HTML→markdown tables, fixes OCR. 813 docs cleaned → `out/cleaned/`, −30% chars.
+  Re-chunked from CLEANED md + noise-table filter (drop change-record/acronym/approval tables):
+  **27,796 clean chunks, 9.64M tokens, ~$2.41 to embed**. 0 tiny chunks.
+- Pipeline order is now: clean_md.py → chunk_docs.py → embed.py → load_qdrant.py → search.py.
+- 2026-06-23 01:20: **QUOTA REALITY on the AQ express key (free tier):**
+  - realtime embed: `online_prediction_requests_per_base_model` for `gemini-embedding-2` is ~0 RPM
+    on preview → realtime is NOT viable for 27k chunks.
+  - Batch API works but free-tier caps: a single big job (9.6M tok / 38MB) is rejected with
+    "exceeded your current quota / check plan & billing"; ~1000-chunk jobs are accepted;
+    only ~1800 chunks can be *enqueued concurrently* before 429. As jobs finish, quota frees.
+  - **Solution = `batch_orchestrator.py` + `batch_loop.sh`**: shard into 800-chunk batch jobs,
+    poll/download/merge, submit more each pass until quota, repeat every 10 min. Resumable via
+    `out/batch_state.json`. Writes `out/EMBEDDING_DONE` then auto-builds Qdrant index + verifies.
+  - **THE CLEAN FIX (morning, ~$2, within €50 cap): enable billing on the Google Cloud project /
+    use a paid-tier key.** Then a single full batch (or realtime) finishes in minutes. Free tier
+    may otherwise span >1 day due to a daily batch-token cap.
+- Reranker caveat: Google `semantic-ranker-default@latest` needs GCP ADC + `GCP_PROJECT`
+  (`gcloud auth application-default login`). The AQ API key alone is NOT enough for the ranker;
+  search falls back to dense+BM25 RRF until ADC is configured.
+
+## 2026-06-23 08:40 — PIPELINE VALIDATED END-TO-END ✅
+- Free-tier batch DID complete (~6-9h): first 4 shards SUCCEEDED.
+- Fixed a download bug (`files.download(file=...)` not `name=...`) in batch_orchestrator.py + embed.py.
+- Downloaded + merged **3,398 real embeddings** (38 products) → built partial Qdrant index.
+- **Verified retrieval**: `rag_api.py GLOBAL_ANALYSISFORECAST_PHY_001_024 --query "how is salinity
+  accuracy validated"` returned the exact right docs (QUID "I.3 Estimated Accuracy Numbers",
+  "IV.2 Salinity" table, SQO "Executive summary"). The find-dataset→read-docs flow works.
+- Remaining: finish embedding 3,398/27,796 → 27,796. Grinding via free-tier batch (slow); a few
+  shards complete per ~6-9h cycle. **Enable GCP billing → one full batch finishes in minutes (~$2).**
+- batch_loop.sh keeps polling/downloading/submitting with the fixed code; index auto-rebuilds at ≥99%.
+
+## 2026-06-23 ~14:00 — added catalogue text (all textual products)
+- Harvested ALL textual catalogue content (what the MCP server serves via
+  marine_describe_dataset / marine_search_*) into the RAG via `build_meta_chunks.py`:
+  - **1251 dataset CARDs** (description, best_for, not_good_for, quality_flags, variables, coverage)
+  - **306 product DESCs** (description + summary)
+- Appended to chunks.jsonl (existing order untouched → running embedder unaffected).
+  Total now **29,353 chunks**. RAG now covers datasets at 2 levels: deep PDF docs + structured cards.
+- TODO (optional, user to confirm): also harvest CDS/ADS/EWDS descriptions (cds/_data, 164 datasets).
+
+## Overnight background jobs
+- `batch_loop.sh` (PID logged in out/batch_loop.log) — embedding orchestrator, every 10 min.
+- Monitor: `tail out/batch_loop.log`, `wc -l out/chunks_embedded.jsonl`, `cat out/batch_state.json`.
+
+## How to unblock (one action needed)
+Whitelist IP **134.1.1.80** for the Gemini API key `AQ.Ab8…` in Google Cloud Console
+(API key → Application/IP restrictions), OR remove the IP restriction. The overnight
+runner then completes embedding + indexing automatically. To run manually instead:
+`/Users/dmpantiu/cmip6/cmip6_gpt/.venv/bin/python embed.py --mode realtime && … load_qdrant.py --recreate`
+
+## Reranker note
+`semantic-ranker-default@latest` (search.py `--rerank`) needs GCP ADC + `GCP_PROJECT` env
+(`gcloud auth application-default login`). Without it, search falls back to dense+BM25 RRF fusion.
+
+## Daytime (reviewed) follow-ups
+- Phase E: MCP tools `marine_read_docs` / `marine_search_docs` in copernicus-mcp-dev (TDD + review per CLAUDE.md).
+- Re-run `build_catalog.py` + `chunk_docs.py` (both resumable) when the rest of the docs land tomorrow.

scripts/marine_rag/RAG_SERVER.md

@@ -0,0 +1,69 @@
+# copernicus-rag — MCP server (RAG discovery + EQC docs layer)
+
+Standalone MCP server exposing the marine_rag retrieval stack. Companion to the
+`copernicus` MCP server (which does the actual subsetting/downloading).
+
+- Entry point: `rag_server.py` (stdio). Venv: `marine_rag/.venv` (Python 3.12:
+  mcp, qdrant-client, fastembed, google-genai, numpy).
+- Registered: `claude mcp add copernicus-rag -- .../marine_rag/.venv/bin/python .../marine_rag/rag_server.py`
+  (local scope, project `/Users/dmpantiu/copernicus_mcp`).
+- Index: embedded Qdrant `out/qdrant_db` (~300 MB) —
+  `copernicus_docs` (1415 dataset cards: CMEMS 1251 / CDS 136 / ADS 16 / EWDS 12)
+  and `marine_docs` (29,249 PUM/QUID/SQO chunks for 306 CMEMS products).
+  Plus separate DBs: `deep_docs/qdrant_db` (`cds_docs`, 23,341 CDS/ADS/EWDS deep-doc
+  chunks — Confluence PUGs/ATBDs/PDFs over 165 datasets), `pubs_rag/qdrant_db`
+  (`publications`) and `eqc_qa/qdrant_db` (`eqc_qa`, 1,274 CDS EQC quality-report chunks).
+- Retrieval: hybrid dense+BM25 RRF. Dense query = `gemini-embedding-2-preview`
+  (768-dim, key = `veretex_api_key` in `../.env`, IPv4 forced via `net_ipv4.py`);
+  on embed failure degrades to BM25-only and reports it in `retrieval`.
+  Optional rerank: Google `semantic-ranker-default@latest` (needs `GCP_PROJECT` + ADC).
+
+## Tools (12)
+
+| tool | level | what |
+|---|---|---|
+| `search_datasets(query, store?, top_k?, rerank?)` | L1 discover | RAG search for datasets by description across all 4 stores; hits carry `notebooks[]` (attached code) where available |
+| `get_dataset_docs(id, question?, doc_type?, top_k?, rerank?)` | L2 analyze | deep docs for one dataset — **CMEMS** → PUM/QUID/SQO (`marine_docs`); **CDS/ADS/EWDS** → PUG/ATBD/Confluence (`cds_docs`). Routes by id automatically |
+| `search_docs(query, doc_type?, top_k?, rerank?)` | L2 analyze | global search across the 29k CMEMS doc chunks (cross-product) |
+| `search_deep_docs(query, store?, top_k?, rerank?)` | L2 analyze | global search across the 23k CDS/ADS/EWDS deep-doc chunks (non-marine counterpart of search_docs) |
+| `list_dataset_documents(id)` | L2 analyze | list the product's full documents (doc_id, type, size) |
+| `read_document(doc_id, offset?, max_chars?)` | L2 analyze | pull full doc markdown, paginated; page 0 includes heading outline |
+| `dataset_metadata(id)` | L2 analyze | FULL harvested metadata (variables/units/bounds, services, doc links, references, licence) — backed by `meta_harvest/unified_metadata.json` (1,436 entries) |
+| `search_publications(query, domain?, dataset_or_product_id?, orphan_only?, top_k?, rerank?)` | L3 method | semantic search over the publications RAG (`pubs_rag/qdrant_db`, collection `publications`) |
+| `get_dataset_publications(id, top_k?)` | L3 method | papers cited in the dataset's docs/references (registry: 1,199 DOIs), most-cited first |
+| `read_publication(doi_or_paper_id, offset?, max_chars?)` | L3 method | full parsed paper text (paginated + outline); registry metadata/abstract fallback for unparsed PDFs |
+| `get_eqc_quality_report(query, dataset_id?, aspect?, top_k?, rerank?)` | L4 quality | CDS/C3S EQC quality-assessment reports (27 datasets); results carry `code_notebooks[]` |
+| `get_dataset_code(dataset_id, notebook_id?, kind?, offset?, max_chars?)` | code | runnable example-notebook CODE attached to a dataset (list recipes / full notebook, paginated) |
+
+Intended agent flow:
+`search_datasets` → `dataset_metadata` + `get_dataset_docs` (variables, accuracy, caveats)
+→ `get_dataset_publications`/`search_publications` (methodology) → subset data via the `copernicus` server.
+
+## Publications layer data
+- Registry: `publications/registry/publications.jsonl` — 1,199 DOIs extracted from 813 EQC docs
+  + CDS/ADS/EWDS references; 918 Crossref-resolved; linked coverage CMEMS 303/306.
+- Orphan corpus: 725 parsed CMIP6 papers (`pubs_rag/out/papers.jsonl`, domain-tagged)
+  → 16,683 chunks → Qdrant `pubs_rag/qdrant_db` (separate embedded DB to dodge the marine lock).
+- OA PDFs of registry papers download into `publications/pdfs/` (raw, VLM-parsed later);
+  after parsing, extend the corpus and run `pubs_rag/relink_pubs.py`.
+
+## Notebook code layer (attach, not embed)
+
+Runnable example-notebook code is **attached to datasets** as a serve-time join —
+NOT a separate searchable collection, NOT embedded. Sidecar
+`eqc_qa/notebooks_by_dataset.json` maps `dataset_id -> [notebook records]`;
+`_notebooks()` loads it (cached, restart to refresh). Full code lives as
+`*.md` with verbatim python cells under `eqc_qa/notebooks_code/` and
+`notebook_harvest/parsed/`. `search_datasets` / `get_eqc_quality_report` hits
+carry compact `notebooks[]`; `get_dataset_code` returns the list or one
+notebook's full code. Source: C3S EQC notebooks (Apache-2.0) + harvested
+toolbox/training notebooks (see `eqc_qa/extract_code.py`).
+
+## Operational notes
+
+- Embedded Qdrant is **single-process**: while a Claude session holds the server
+  open, `load_qdrant.py` / `load_copernicus_docs.py` will fail on the lock.
+  Stop sessions (or `claude mcp remove copernicus-rag` temporarily) before rebuilding.
+- First tool call is slow (~5–10 s): opens the 300 MB index + loads the BM25 model.
+- stdout is the JSON-RPC channel — all logging is pinned to stderr at import time.
+- Smoke test: `.venv/bin/python -c "import rag_server as R; print(R.search_datasets('arctic sea ice', top_k=3)['results'][0])"`

scripts/marine_rag/batch_loop.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# batch_loop.sh — run the batch orchestrator every 10 min until embedding done.
+# Each pass: poll in-flight shard jobs, download completed, submit more shards
+# until the daily quota 429s. Stops when out/EMBEDDING_DONE appears.
+set -uo pipefail
+cd /Users/dmpantiu/copernicus_mcp/marine_rag
+PY=/Users/dmpantiu/cmip6/cmip6_gpt/.venv/bin/python
+LOG=out/batch_loop.log
+INTERVAL=180   # poll often so the freed 500k active-token budget refills fast
+MAX=400   # ~20h at 180s
+
+ts(){ date '+%Y-%m-%d %H:%M:%S'; }
+log(){ echo "[$(ts)] $*" | tee -a "$LOG"; }
+
+log "=== batch loop started ==="
+i=0
+while [ "$i" -lt "$MAX" ]; do
+  i=$((i+1))
+  if [ -f out/EMBEDDING_DONE ]; then
+    log "EMBEDDING_DONE present — stopping loop."
+    break
+  fi
+  log "pass $i"
+  $PY batch_orchestrator.py >> "$LOG" 2>&1
+  emb=$([ -f out/chunks_embedded.jsonl ] && wc -l < out/chunks_embedded.jsonl | tr -d ' ' || echo 0)
+  log "pass $i done — embedded $emb/27796"
+  [ -f out/EMBEDDING_DONE ] && { log "complete."; break; }
+  sleep "$INTERVAL"
+done
+log "=== batch loop exiting (pass $i) ==="

scripts/marine_rag/batch_orchestrator.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+batch_orchestrator.py — embed all marine chunks via the Gemini Batch API in
+free-tier-sized shards. One pass per invocation; call repeatedly (cron/loop):
+
+  - poll in-flight shard jobs; download + merge completed ones → chunks_embedded.jsonl
+  - submit new shards from where we left off until the daily quota 429s
+  - when ≥99% embedded, build Qdrant index + run a verification search, then exit 0
+
+State: out/batch_state.json  (shards, job names, statuses, next_start)
+Idempotent + resumable. Free-tier batch jobs are slow (minutes–hours).
+"""
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import net_ipv4  # noqa: F401  force IPv4
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+CHUNKS = OUT / "chunks.jsonl"
+EMB = OUT / "chunks_embedded.jsonl"
+STATE = OUT / "batch_state.json"
+SHARD_DIR = OUT / "_shards"
+PY = "/Users/dmpantiu/cmip6/cmip6_gpt/.venv/bin/python"
+
+MODEL = "gemini-embedding-2-preview"
+SHARD_SIZE = 800
+TASK_TYPE = "RETRIEVAL_DOCUMENT"
+DIM = 768
+
+
+def resolve_key():
+    for env in (Path("/Users/dmpantiu/copernicus_mcp/.env"),
+                Path("/Users/dmpantiu/cmip6/cmip6_gpt/.env")):
+        if env.exists():
+            for line in env.read_text().splitlines():
+                line = line.strip()
+                if "api_key" in line.lower() and "=" in line and not line.startswith("#"):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("no key")
+
+
+def client():
+    from google import genai
+    return genai.Client(api_key=resolve_key())
+
+
+def l2(v):
+    import numpy as np
+    a = np.array(v, dtype=np.float32)
+    n = np.linalg.norm(a)
+    return (a / n).tolist() if n > 0 else a.tolist()
+
+
+def load_state():
+    if STATE.exists():
+        return json.loads(STATE.read_text())
+    return {"shards": [], "next_start": 0}
+
+
+def save_state(s):
+    STATE.write_text(json.dumps(s, indent=1))
+
+
+def embedded_keys():
+    keys = set()
+    if EMB.exists():
+        for line in open(EMB):
+            try:
+                keys.add(json.loads(line)["chunk_id"])
+            except Exception:
+                pass
+    return keys
+
+
+def extract_values(resp):
+    for path in (("response", "embeddings"), ("response", "embedding"), ("embeddings",), ("embedding",)):
+        node = resp
+        ok = True
+        for k in path:
+            if isinstance(node, dict) and k in node:
+                node = node[k]
+            else:
+                ok = False
+                break
+        if not ok:
+            continue
+        if isinstance(node, list) and node and isinstance(node[0], dict) and "values" in node[0]:
+            return node[0]["values"]
+        if isinstance(node, dict) and "values" in node:
+            return node["values"]
+    return None
+
+
+def main():
+    SHARD_DIR.mkdir(exist_ok=True)
+    chunks = [json.loads(l) for l in open(CHUNKS)]
+    by_key = {c["chunk_id"]: c for c in chunks}
+    total = len(chunks)
+    state = load_state()
+    c = client()
+    from google import genai  # noqa
+
+    # 1) poll in-flight jobs; download completed
+    done_keys = embedded_keys()
+    with open(EMB, "a", encoding="utf-8") as fout:
+        for sh in state["shards"]:
+            if sh["status"] == "done":
+                continue
+            try:
+                job = c.batches.get(name=sh["job"])
+            except Exception as e:
+                print(f"shard {sh['idx']}: poll err {str(e)[:80]}")
+                continue
+            st = str(job.state).split(".")[-1]
+            sh["state"] = st
+            if "SUCCEEDED" not in st:
+                if any(x in st for x in ("FAILED", "CANCELLED", "EXPIRED")):
+                    sh["status"] = "failed"  # will be resubmitted (range reopened)
+                    state["next_start"] = min(state["next_start"], sh["start"])
+                print(f"shard {sh['idx']} [{sh['start']}:{sh['end']}]: {st}")
+                continue
+            dest = getattr(job, "dest", None)
+            fn = getattr(dest, "file_name", None) if dest else None
+            lines = []
+            if fn:
+                lines = c.files.download(file=fn).decode("utf-8").strip().split("\n")
+            elif dest and getattr(dest, "inlined_responses", None):
+                lines = [json.dumps(r) for r in dest.inlined_responses]
+            got = 0
+            for line in lines:
+                if not line.strip():
+                    continue
+                r = json.loads(line)
+                k = r.get("key") or r.get("custom_metadata") or r.get("custom_id")
+                if k in done_keys or k not in by_key:
+                    continue
+                vals = extract_values(r)
+                if vals:
+                    rec = dict(by_key[k])
+                    rec["embedding"] = l2(vals)
+                    fout.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                    done_keys.add(k)
+                    got += 1
+            sh["status"] = "done"
+            sh["downloaded"] = got
+            print(f"shard {sh['idx']} [{sh['start']}:{sh['end']}]: DONE +{got}")
+    save_state(state)
+
+    n_emb = len(done_keys)
+    print(f"embedded {n_emb}/{total}")
+
+    # 2) submit new shards until quota stops us
+    submitted_now = 0
+    covered = {(sh["start"], sh["end"]) for sh in state["shards"] if sh["status"] != "failed"}
+    start = state["next_start"]
+    while start < total:
+        end = min(start + SHARD_SIZE, total)
+        if (start, end) in covered:
+            start = end
+            continue
+        shard_path = SHARD_DIR / f"shard_{start}_{end}.jsonl"
+        with open(shard_path, "w", encoding="utf-8") as f:
+            for ch in chunks[start:end]:
+                f.write(json.dumps({"key": ch["chunk_id"], "request": {
+                    "content": {"parts": [{"text": ch["text_with_prefix"]}]},
+                    "task_type": TASK_TYPE, "output_dimensionality": DIM}}) + "\n")
+        try:
+            up = c.files.upload(file=str(shard_path),
+                                config={"display_name": f"sh_{start}", "mime_type": "jsonl"})
+            job = c.batches.create_embeddings(model=MODEL, src={"file_name": up.name},
+                                              config={"display_name": f"sh_{start}_{end}"})
+            state["shards"].append({"idx": len(state["shards"]), "start": start, "end": end,
+                                    "job": job.name, "status": "running",
+                                    "state": str(job.state).split(".")[-1]})
+            state["next_start"] = end
+            submitted_now += 1
+            print(f"submitted shard [{start}:{end}] -> {job.name.split('/')[-1]}")
+            save_state(state)
+            start = end
+            time.sleep(3)
+        except Exception as e:
+            es = str(e)
+            print(f"submit stop at [{start}:{end}]: {es[:120]}")
+            break
+    save_state(state)
+    print(f"submitted {submitted_now} new shards this pass")
+
+    # 3) finish when essentially complete
+    if n_emb >= total * 0.99:
+        print("EMBEDDING COMPLETE — building index + verifying")
+        subprocess.run([PY, "load_qdrant.py", "--recreate"], cwd=ROOT)
+        subprocess.run([PY, "search.py", "how is sea surface salinity validated", "--top-k", "3"], cwd=ROOT)
+        Path(OUT / "EMBEDDING_DONE").write_text(f"{n_emb}/{total}\n")
+        return 0
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/marine_rag/build_catalog.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+build_catalog.py — Join marine_parsed docs to the copernicus-mcp catalogue.
+
+Output: out/catalog.json — one entry per product:
+  product_id, product_title, group(s), domains/regions, dataset_ids,
+  docs: [{doc_id, doc_type, md_path, md_bytes, has_md}], coverage flags.
+
+Pure local. No API.
+"""
+import json
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+WS = ROOT.parent
+PARSED = WS / "marine_parsed"
+DATA = WS / "copernicus-mcp-dev" / "src" / "copernicus_mcp" / "backends" / "cmems" / "_data"
+OUT = ROOT / "out"
+OUT.mkdir(exist_ok=True)
+
+DOC_TYPES = ("PUM", "QUID", "SQO")
+
+
+def doc_type_of(doc_id: str) -> str:
+    """Classify a CMEMS document id by its type token (PUM/QUID/SQO/OTHER)."""
+    u = doc_id.upper()
+    for t in DOC_TYPES:
+        if re.search(rf"(^|[-_]){t}([-_]|$)", u):
+            return t
+    if "PUM" in u:
+        return "PUM"
+    if "QUID" in u:
+        return "QUID"
+    return "OTHER"
+
+
+def find_md_files(product_dir: Path) -> list[Path]:
+    """All vlm markdown files under a product folder."""
+    return sorted(product_dir.rglob("vlm/*.md"))
+
+
+def main() -> None:
+    products = json.loads((DATA / "products.json").read_text())
+    by_pid = {p["product_id"]: p for p in products}
+
+    # group membership: groups.json maps group -> product ids (shape-tolerant)
+    groups_raw = json.loads((DATA / "groups.json").read_text())
+    pid_to_groups: dict[str, list[str]] = {}
+
+    def _index_group(gid: str, obj) -> None:
+        pids: list[str] = []
+        if isinstance(obj, dict):
+            for key in ("product_ids", "products", "member_product_ids", "members"):
+                v = obj.get(key)
+                if isinstance(v, list):
+                    pids.extend(str(x) for x in v)
+        elif isinstance(obj, list):
+            pids.extend(str(x) for x in obj)
+        for pid in pids:
+            pid_to_groups.setdefault(pid, [])
+            if gid not in pid_to_groups[pid]:
+                pid_to_groups[pid].append(gid)
+
+    if isinstance(groups_raw, dict):
+        for gid, obj in groups_raw.items():
+            _index_group(gid, obj)
+    elif isinstance(groups_raw, list):
+        for obj in groups_raw:
+            gid = obj.get("group_id") or obj.get("id") or obj.get("name") if isinstance(obj, dict) else None
+            if gid:
+                _index_group(gid, obj)
+
+    parsed_folders = {p.name for p in PARSED.iterdir() if p.is_dir()}
+
+    catalog = []
+    n_with_docs = 0
+    docs_total = 0
+    for pid, p in sorted(by_pid.items()):
+        pdir = PARSED / pid
+        docs = []
+        if pdir.is_dir():
+            for md in find_md_files(pdir):
+                doc_id = md.stem
+                docs.append({
+                    "doc_id": doc_id,
+                    "doc_type": doc_type_of(doc_id),
+                    "md_path": str(md.relative_to(WS)),
+                    "md_bytes": md.stat().st_size,
+                    "has_md": md.stat().st_size > 0,
+                    # 230-byte blank SQO template shells (upstream published an
+                    # unfilled form) -> flagged so RAG can skip empty stubs.
+                    "has_content": md.stat().st_size > 300,
+                })
+        docs_total += len(docs)
+        if docs:
+            n_with_docs += 1
+        catalog.append({
+            "product_id": pid,
+            "product_title": p.get("product_title", ""),
+            "groups": pid_to_groups.get(pid, []),
+            "domains": p.get("domains", []),
+            "regions": p.get("regions", []),
+            "data_types": p.get("data_types", []),
+            "dataset_ids": p.get("dataset_ids", []),
+            "dataset_count": p.get("dataset_count", len(p.get("dataset_ids", []))),
+            "doi": p.get("doi", ""),
+            "doc_count": len(docs),
+            "doc_types": sorted({d["doc_type"] for d in docs}),
+            "has_docs": bool(docs),
+            "docs": docs,
+        })
+
+    extra_folders = sorted(parsed_folders - set(by_pid))
+    missing_docs = sorted(pid for pid in by_pid if not (PARSED / pid).is_dir() or not find_md_files(PARSED / pid))
+
+    (OUT / "catalog.json").write_text(json.dumps(catalog, ensure_ascii=False, indent=1))
+    summary = {
+        "products_total": len(by_pid),
+        "products_with_docs": n_with_docs,
+        "products_missing_docs": len(missing_docs),
+        "docs_total": docs_total,
+        "parsed_folders": len(parsed_folders),
+        "extra_folders_not_in_catalogue": extra_folders,
+        "missing_docs_product_ids": missing_docs,
+    }
+    (OUT / "catalog_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=1))
+    print(json.dumps(summary, ensure_ascii=False, indent=1))
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/build_cds_cards.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+build_cds_cards.py — harvest CDS/ADS/EWDS STAC catalogue metadata into RAG
+"card" chunks (one dataset = one card), mirroring the Marine CARD format so a
+single `copernicus_docs` index can be queried across all four stores.
+
+Sources (already snapshotted locally, fetched 2026-05-16):
+  backends/cds/_data/{cds,ads,ewds}.json          — STAC collections
+  backends/cds/_data/{cds,ads,ewds}_constraints.json — downloadable variables/options
+
+Output: out/cds_cards_chunks.jsonl  (schema-compatible with chunks.jsonl)
+"""
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+DATA = ROOT.parent / "copernicus-mcp-dev" / "src" / "copernicus_mcp" / "backends" / "cds" / "_data"
+OUT_JSONL = OUT / "cds_cards_chunks.jsonl"
+sys.path.insert(0, "/Users/dmpantiu/cmip6/cmip6_gpt/rag")
+from chunk_papers import count_tokens  # noqa: E402
+
+STORE_LABEL = {"cds": "CDS (Climate Data Store)",
+               "ads": "ADS (Atmosphere Data Store)",
+               "ewds": "EWDS (Early Warning Data Store)"}
+
+
+def j(v):
+    if isinstance(v, list):
+        return "; ".join(str(x) for x in v if x is not None)
+    return str(v) if v is not None else ""
+
+
+def coverage(extent: dict) -> str:
+    if not extent:
+        return ""
+    parts = []
+    sp = (extent.get("spatial") or {}).get("bbox") or []
+    if sp and sp[0]:
+        b = sp[0]
+        parts.append(f"bbox {b[0]},{b[1]} → {b[2]},{b[3]}")
+    tp = (extent.get("temporal") or {}).get("interval") or []
+    if tp and tp[0]:
+        s = (tp[0][0] or "")[:10]
+        e = (tp[0][1] or "")[:10]
+        parts.append(f"time {s} → {e}")
+    return " | ".join(parts)
+
+
+def variables(constraint: dict) -> list:
+    """Union of variable-like option lists across all constraint blocks."""
+    if not constraint:
+        return []
+    vs = []
+    blocks = constraint if isinstance(constraint, list) else [constraint]
+    seen = set()
+    for blk in blocks:
+        if not isinstance(blk, dict):
+            continue
+        for key in ("variable", "variables", "product_type", "parameter"):
+            for v in blk.get(key) or []:
+                if v not in seen:
+                    seen.add(v)
+                    vs.append(v)
+    return vs
+
+
+def card_text(store: str, c: dict, cons: dict) -> str:
+    did = c.get("id", "")
+    lines = [
+        f'Dataset: "{c.get("title","")}" [{did}]',
+        f'Store: {STORE_LABEL[store]}',
+    ]
+    kw = c.get("keywords") or []
+    if kw:
+        lines.append(f'Keywords: {j(kw)}')
+    cov = coverage(c.get("extent") or {})
+    if cov:
+        lines.append(f'Coverage: {cov}')
+    vs = variables(cons.get(did))
+    if vs:
+        shown = vs[:40]
+        more = f" (+{len(vs)-40} more)" if len(vs) > 40 else ""
+        lines.append(f'Variables/options: {j(shown)}{more}')
+    prov = "; ".join(p.get("name", "") for p in (c.get("providers") or []))
+    if prov:
+        lines.append(f'Provider: {prov}')
+    if c.get("license"):
+        lines.append(f'License: {c.get("license")}')
+    if c.get("sci:doi"):
+        lines.append(f'DOI: {c.get("sci:doi")}')
+    freq = c.get("cads:update_frequency")
+    if freq:
+        lines.append(f'Update frequency: {freq}')
+    desc = (c.get("description") or "").strip()
+    body = "\n".join(lines)
+    if desc:
+        body += "\n---\n" + desc
+    return body
+
+
+def mk(store: str, did: str, title: str, text: str) -> dict:
+    h = hashlib.md5(text.encode()).hexdigest()
+    return {
+        "chunk_id": f"{did}__{store}_card__{h[:12]}",
+        "product_id": did,             # dataset id doubles as product id for CDS-family
+        "product_title": title,
+        "doc_id": did,
+        "doc_type": "CARD",
+        "section_path": "catalogue",
+        "section_name": "catalogue",
+        "chunk_type": "card",
+        "chunk_index": 0,
+        "token_count": count_tokens(text),
+        "text_with_prefix": text,
+        "text_raw": text,
+        "store": store.upper(),        # NEW payload field for cross-store filtering
+    }
+
+
+def main() -> None:
+    rows, toks = [], 0
+    for store in ("cds", "ads", "ewds"):
+        cols = json.loads((DATA / f"{store}.json").read_text())["collections"]
+        cons = json.loads((DATA / f"{store}_constraints.json").read_text())
+        for c in cols:
+            did = c.get("id", "")
+            if not did:
+                continue
+            text = card_text(store, c, cons)
+            r = mk(store, did, c.get("title", ""), text)
+            rows.append(r)
+            toks += r["token_count"]
+        print(f"  {store.upper()}: {len(cols)} cards")
+    with open(OUT_JSONL, "w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    print(f"wrote {len(rows)} cards ({toks:,} tokens, "
+          f"~${toks/1e6*0.25:.3f} realtime / ${toks/1e6*0.125:.3f} batch) → {OUT_JSONL}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/build_meta_chunks.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+build_meta_chunks.py — harvest ALL textual catalogue content (what the MCP
+server serves via marine_describe_dataset / marine_search_*) into RAG chunks:
+
+  - dataset_cards.json  → 1251 DATASET-level cards (description, best_for,
+    not_good_for, quality_flags, variables, coverage, service types)
+  - products.json       → 306 PRODUCT descriptions + summaries
+
+These complement the PUM/QUID/SQO PDF docs with concise, structured,
+per-dataset "how to use / what it's good/bad for" text.
+
+APPENDS to out/chunks.jsonl (existing line order untouched, so the running
+batch embedder's index ranges stay valid). Skips chunk_ids already present.
+"""
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+DATA = ROOT.parent / "copernicus-mcp-dev" / "src" / "copernicus_mcp" / "backends" / "cmems" / "_data"
+CHUNKS = OUT / "chunks.jsonl"
+sys.path.insert(0, "/Users/dmpantiu/cmip6/cmip6_gpt/rag")
+from chunk_papers import count_tokens  # noqa: E402
+
+
+def j(v):
+    if isinstance(v, list):
+        return "; ".join(str(x) for x in v if x is not None)
+    return str(v) if v is not None else ""
+
+
+def card_text(c: dict) -> str:
+    lines = [f'Dataset: "{c.get("dataset_name","")}" [{c.get("dataset_id","")}]',
+             f'Product: {c.get("product_title","")} [{c.get("product_id","")}]']
+    if c.get("spatial_label") or c.get("temporal_label"):
+        lines.append(f'Coverage: {j(c.get("spatial_label"))} | {j(c.get("temporal_label"))}')
+    if c.get("variables"):
+        lines.append(f'Variables: {j(c.get("variables"))}')
+    if c.get("service_types"):
+        lines.append(f'Service types: {j(c.get("service_types"))}')
+    if c.get("best_for"):
+        lines.append(f'Best for: {j(c.get("best_for"))}')
+    if c.get("not_good_for"):
+        lines.append(f'Not good for: {j(c.get("not_good_for"))}')
+    if c.get("quality_flags"):
+        lines.append(f'Quality flags: {j(c.get("quality_flags"))}')
+    desc = (c.get("description") or "").strip()
+    body = "\n".join(lines)
+    if desc:
+        body += "\n---\n" + desc
+    return body
+
+
+def prod_text(p: dict) -> str:
+    lines = [f'Product: "{p.get("product_title","")}" [{p.get("product_id","")}]']
+    if p.get("domains") or p.get("regions"):
+        lines.append(f'Domains: {j(p.get("domains"))} | Regions: {j(p.get("regions"))}')
+    if p.get("variables"):
+        lines.append(f'Variables: {j(p.get("variables"))}')
+    if p.get("doi"):
+        lines.append(f'DOI: {p.get("doi")}')
+    parts = [p.get("summary", ""), p.get("description", "")]
+    body = "\n".join(lines) + "\n---\n" + "\n\n".join(x for x in parts if x)
+    return body.strip()
+
+
+def mk(product_id, product_title, doc_id, doc_type, chunk_type, text):
+    h = hashlib.md5(text.encode()).hexdigest()
+    return {
+        "chunk_id": f"{product_id}__{doc_type.lower()}_{doc_id}__{h[:12]}",
+        "product_id": product_id, "product_title": product_title,
+        "doc_id": doc_id, "doc_type": doc_type,
+        "section_path": "catalogue", "section_name": "catalogue",
+        "chunk_type": chunk_type, "chunk_index": 0,
+        "token_count": count_tokens(text),
+        "text_with_prefix": text, "text_raw": text,
+    }
+
+
+def main() -> None:
+    cards = json.loads((DATA / "dataset_cards.json").read_text())
+    prods = json.loads((DATA / "products.json").read_text())
+    if isinstance(cards, dict):
+        cards = list(cards.values())
+
+    existing = set()
+    if CHUNKS.exists():
+        for line in open(CHUNKS):
+            try:
+                existing.add(json.loads(line)["chunk_id"])
+            except Exception:
+                pass
+
+    new = []
+    for c in cards:
+        pid = c.get("product_id", "")
+        did = c.get("dataset_id", "")
+        if not pid or not did:
+            continue
+        new.append(mk(pid, c.get("product_title", ""), did, "CARD", "card", card_text(c)))
+    for p in prods:
+        pid = p.get("product_id", "")
+        new.append(mk(pid, p.get("product_title", ""), pid, "DESC", "desc", prod_text(p)))
+
+    added = 0
+    toks = 0
+    with open(CHUNKS, "a", encoding="utf-8") as f:
+        for r in new:
+            if r["chunk_id"] in existing:
+                continue
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+            existing.add(r["chunk_id"])
+            added += 1
+            toks += r["token_count"]
+    print(f"appended {added} meta chunks ({toks:,} tokens, ~${toks/1e6*0.125:.3f} batch) → {CHUNKS}")
+    print(f"  cards={len(cards)} products={len(prods)}; total chunks now {len(existing)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/build_missing_cds_cards.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""build_missing_cds_cards.py — add L0 cards for the CDS datasets that were in the
+RAG universe (unified_metadata) but absent from the stale cds.json bundle (136 vs 139),
+so build_cds_cards.py never carded them. Builds cards in the EXACT existing format from
+unified_metadata and appends them to out/cds_cards_chunks.jsonl (idempotent, backed up)."""
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+OUT_JSONL = OUT / "cds_cards_chunks.jsonl"
+UNI = ROOT.parent / "meta_harvest" / "unified_metadata.json"
+sys.path.insert(0, "/Users/dmpantiu/cmip6/cmip6_gpt/rag")
+from chunk_papers import count_tokens  # noqa: E402
+
+STORE_LABEL = {"cds": "CDS (Climate Data Store)",
+               "ads": "ADS (Atmosphere Data Store)",
+               "ewds": "EWDS (Early Warning Data Store)"}
+
+MISSING = [
+    "satellite-snow-cover-extent",
+    "sis-agrometeorological-indicators-timeseries",
+    "sis-energy-global-reanalysis",
+]
+
+
+def j(v):
+    if isinstance(v, list):
+        return "; ".join(str(x) for x in v if x is not None)
+    return str(v) if v is not None else ""
+
+
+def card_text(did: str, e: dict) -> str:
+    store = (e.get("store") or "cds").lower()
+    lines = [
+        f'Dataset: "{e.get("title","")}" [{did}]',
+        f'Store: {STORE_LABEL.get(store, store.upper())}',
+    ]
+    kw = e.get("keywords") or []
+    if kw:
+        lines.append(f'Keywords: {j(kw)}')
+    # coverage from spatial_bbox + temporal_range
+    cov = []
+    bb = e.get("spatial_bbox") or []
+    if len(bb) == 4:
+        cov.append(f"bbox {bb[0]},{bb[1]} → {bb[2]},{bb[3]}")
+    tr = e.get("temporal_range") or []
+    if len(tr) == 2 and tr[0]:
+        cov.append(f"time {(tr[0] or '')[:10]} → {(tr[1] or '')[:10]}")
+    if cov:
+        lines.append(f'Coverage: {" | ".join(cov)}')
+    vs = [v.get("short_name") for v in (e.get("variables") or []) if isinstance(v, dict) and v.get("short_name")]
+    if vs:
+        shown = vs[:40]
+        more = f" (+{len(vs)-40} more)" if len(vs) > 40 else ""
+        lines.append(f'Variables/options: {j(shown)}{more}')
+    if e.get("production_center"):
+        lines.append(f'Provider: {e["production_center"]}')
+    if e.get("licence"):
+        lines.append(f'License: {e["licence"]}')
+    if e.get("doi"):
+        lines.append(f'DOI: {e["doi"]}')
+    if e.get("update_frequency"):
+        lines.append(f'Update frequency: {e["update_frequency"]}')
+    return "\n".join(lines)
+
+
+def mk(store: str, did: str, title: str, text: str) -> dict:
+    h = hashlib.md5(text.encode()).hexdigest()
+    return {
+        "chunk_id": f"{did}__{store}_card__{h[:12]}",
+        "product_id": did,
+        "product_title": title,
+        "doc_id": did,
+        "doc_type": "CARD",
+        "section_path": "catalogue",
+        "section_name": "catalogue",
+        "chunk_type": "card",
+        "chunk_index": 0,
+        "token_count": count_tokens(text),
+        "text_with_prefix": text,
+        "text_raw": text,
+        "store": store.upper(),
+    }
+
+
+def main() -> None:
+    uni = json.loads(UNI.read_text())
+    existing_ids = set()
+    if OUT_JSONL.exists():
+        for line in OUT_JSONL.open():
+            line = line.strip()
+            if line:
+                existing_ids.add(json.loads(line).get("product_id"))
+    new_rows = []
+    for did in MISSING:
+        if did in existing_ids:
+            print(f"SKIP (already carded): {did}")
+            continue
+        e = uni.get(did)
+        if not e:
+            print(f"WARN not in universe: {did}")
+            continue
+        store = (e.get("store") or "cds").lower()
+        text = card_text(did, e)
+        new_rows.append(mk(store, did, e.get("title", ""), text))
+        print(f"\n=== CARD {did} ===\n{text}\n")
+    if not new_rows:
+        print("nothing to add.")
+        return
+    # backup then append
+    if OUT_JSONL.exists():
+        bak = OUT_JSONL.with_suffix(".jsonl.bak")
+        bak.write_bytes(OUT_JSONL.read_bytes())
+        print(f"backup -> {bak}")
+    with OUT_JSONL.open("a", encoding="utf-8") as f:
+        for r in new_rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    total = sum(1 for line in OUT_JSONL.open() if line.strip())
+    print(f"appended {len(new_rows)} cards -> {OUT_JSONL} (now {total} rows)")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/build_tree.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+build_tree.py — Beautiful descending trees of the Copernicus Marine catalogue.
+
+Outputs:
+  out/tree.txt           — routing-group view (Catalogue > Group > Product > Datasets)
+  out/tree_by_region.txt — geographic view (Region > Domain > Product)
+  out/tree.md            — nested markdown for docs
+
+Doc-coverage badge per product: [PUM|QUID|SQO]  (✓ present)  or  [no docs].
+Pure local. No API.
+"""
+import json
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+DATA = ROOT.parent / "copernicus-mcp-dev" / "src" / "copernicus_mcp" / "backends" / "cmems" / "_data"
+OUT = ROOT / "out"
+
+VB, BR, LA, SP = "│  ", "├─ ", "└─ ", "   "
+
+
+def badge(c: dict) -> str:
+    if not c["has_docs"]:
+        return "[no docs]"
+    return "[" + "|".join(c["doc_types"]) + "]"
+
+
+def render_product(c: dict, prefix: str, last: bool, show_datasets: bool) -> list[str]:
+    conn = LA if last else BR
+    lines = [f"{prefix}{conn}{c['product_id']}  {badge(c)}  — {c['product_title']}"]
+    if show_datasets:
+        child_prefix = prefix + (SP if last else VB)
+        dss = c["dataset_ids"]
+        for i, ds in enumerate(dss):
+            dconn = LA if i == len(dss) - 1 else BR
+            lines.append(f"{child_prefix}{dconn}{ds}")
+    return lines
+
+
+def main() -> None:
+    catalog = json.loads((OUT / "catalog.json").read_text())
+    by_pid = {c["product_id"]: c for c in catalog}
+    groups = json.loads((DATA / "groups.json").read_text())
+
+    # ── Tree 1: routing groups ────────────────────────────────────────────
+    lines = []
+    n_prod_docs = sum(1 for c in catalog if c["has_docs"])
+    lines.append("COPERNICUS MARINE (CMEMS) — catalogue documentation tree")
+    lines.append(f"{len(catalog)} products · {sum(c['dataset_count'] for c in catalog)} datasets · "
+                 f"{len(groups)} routing groups · docs: {n_prod_docs}/{len(catalog)} products covered")
+    lines.append("=" * 78)
+    lines.append("ROOT")
+    groups_sorted = sorted(groups, key=lambda g: g["group_id"])
+    for gi, g in enumerate(groups_sorted):
+        glast = gi == len(groups_sorted) - 1
+        gconn = LA if glast else BR
+        pids = [p for p in g["product_ids"] if p in by_pid]
+        cov = sum(1 for p in pids if by_pid[p]["has_docs"])
+        lines.append(f"{gconn}{g['group_id']}  ({cov}/{len(pids)} docs)  — {g['group_title']}")
+        gpref = SP if glast else VB
+        for pi, pid in enumerate(sorted(pids)):
+            plast = pi == len(pids) - 1
+            lines.extend(render_product(by_pid[pid], gpref, plast, show_datasets=False))
+    (OUT / "tree.txt").write_text("\n".join(lines) + "\n")
+
+    # ── Tree 2: by region > domain (from product metadata) ────────────────
+    rlines = ["COPERNICUS MARINE — geographic view (region > domain > product)", "=" * 78, "ROOT"]
+    region_map: dict[str, dict[str, list[dict]]] = defaultdict(lambda: defaultdict(list))
+    for c in catalog:
+        region = (c["regions"][0] if c["regions"] else "global").replace("_", " ")
+        domain = (c["domains"][0] if c["domains"] else "other").replace("_", " ")
+        region_map[region][domain].append(c)
+    regions_sorted = sorted(region_map)
+    for ri, region in enumerate(regions_sorted):
+        rlast = ri == len(regions_sorted) - 1
+        rconn = LA if rlast else BR
+        rcount = sum(len(v) for v in region_map[region].values())
+        rlines.append(f"{rconn}{region}  ({rcount} products)")
+        rpref = SP if rlast else VB
+        domains_sorted = sorted(region_map[region])
+        for di, domain in enumerate(domains_sorted):
+            dlast = di == len(domains_sorted) - 1
+            dconn = LA if dlast else BR
+            prods = sorted(region_map[region][domain], key=lambda c: c["product_id"])
+            rlines.append(f"{rpref}{dconn}{domain}  ({len(prods)})")
+            dpref = rpref + (SP if dlast else VB)
+            for pi, c in enumerate(prods):
+                plast = pi == len(prods) - 1
+                rlines.extend(render_product(c, dpref, plast, show_datasets=False))
+    (OUT / "tree_by_region.txt").write_text("\n".join(rlines) + "\n")
+
+    # ── Tree 3: markdown (nested list, by group) ──────────────────────────
+    md = ["# Copernicus Marine catalogue tree", "",
+          f"- **{len(catalog)} products** · **{sum(c['dataset_count'] for c in catalog)} datasets** · "
+          f"**{len(groups)} routing groups** · docs {n_prod_docs}/{len(catalog)} products", ""]
+    for g in groups_sorted:
+        pids = [p for p in g["product_ids"] if p in by_pid]
+        cov = sum(1 for p in pids if by_pid[p]["has_docs"])
+        md.append(f"## {g['group_title']}  `({cov}/{len(pids)} docs)`")
+        md.append(f"<sub>`{g['group_id']}` — {g['summary']}</sub>")
+        md.append("")
+        for pid in sorted(pids):
+            c = by_pid[pid]
+            md.append(f"- `{pid}` {badge(c)} — {c['product_title']} "
+                      f"<sub>({c['dataset_count']} datasets)</sub>")
+        md.append("")
+    (OUT / "tree.md").write_text("\n".join(md) + "\n")
+
+    print("wrote out/tree.txt, out/tree_by_region.txt, out/tree.md")
+    print(f"products={len(catalog)} groups={len(groups)} docs_covered={n_prod_docs}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/chunk_docs.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""
+chunk_docs.py — Section-aware chunking of marine_parsed VLM markdown.
+
+Reuses the battle-tested chunker from cmip6_gpt/rag/chunk_papers.py
+(noise filters, OCR-ris fixes, dedup, overlap, token budget) but assembles
+a marine-specific prefix: product, document type (PUM/QUID/SQO), section path.
+Images are ignored (markdown image refs are skipped by the parser).
+
+Output: out/chunks.jsonl  — one JSON object per chunk. Resumable per md file.
+"""
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+WS = ROOT.parent
+PARSED = WS / "marine_parsed"
+OUT = ROOT / "out"
+CMIP6_RAG = Path("/Users/dmpantiu/cmip6/cmip6_gpt/rag")
+
+sys.path.insert(0, str(CMIP6_RAG))
+from chunk_papers import (  # noqa: E402
+    parse_markdown_sections, fix_ocr_ris_stripping, clean_ui_from_text,
+    is_garbage_section_path, is_figure_axis_gibberish, is_digit_heavy_garbage,
+    is_boilerplate_noise, is_affiliation_fragment, is_reference_block,
+    has_repeating_loop, is_url_only, chunk_text_block, add_overlap, count_tokens,
+    MAX_TOKENS, MIN_QUALITY_TOKENS, MIN_TOKENS, OVERLAP_RATIO, TABLE_MAX_TOKENS,
+)
+
+DOC_TYPES = ("PUM", "QUID", "SQO")
+
+
+def doc_type_of(doc_id: str) -> str:
+    u = doc_id.upper()
+    for t in DOC_TYPES:
+        if re.search(rf"(^|[-_]){t}([-_]|$)", u) or t in u:
+            return t
+    return "OTHER"
+
+
+def is_noise_table(tbl_text: str) -> bool:
+    """Drop document-meta tables (change record, approval, acronyms) — pure noise."""
+    head = "\n".join(tbl_text.lower().splitlines()[:3])
+    if "description of change" in head:
+        return True
+    if ("validated by" in head or "checked by" in head) and ("issue" in head or "date" in head):
+        return True
+    if "acronym" in head and "description" in head:
+        return True
+    if head.count("|") >= 4 and ("abbreviation" in head and "meaning" in head):
+        return True
+    return False
+
+
+def make_prefix(product_id: str, title: str, doc_id: str, doc_type: str, section_path: str) -> str:
+    head = f'Product: "{title}" [{product_id}]' if title else f"Product: {product_id}"
+    return (head + f"\nDocument: {doc_type} ({doc_id})"
+            + f"\nSection: {section_path}\n---\n")
+
+
+def chunk_marine_md(md_path: Path, product_id: str, title: str, doc_id: str | None = None) -> list[dict]:
+    if doc_id is None:
+        doc_id = md_path.stem
+    doc_type = doc_type_of(doc_id)
+    md_text = md_path.read_text(encoding="utf-8", errors="replace")
+    sections = parse_markdown_sections(md_text)
+
+    out: list[dict] = []
+    counter = 0
+    seen: set[str] = set()
+
+    for section in sections:
+        if section.paragraphs == ["__EXCLUDED__"]:
+            continue
+        section_path = section.path
+        if is_garbage_section_path(section.name):
+            section_path = "[section unknown]"
+
+        # ── text ──
+        if section.paragraphs:
+            full = fix_ocr_ris_stripping("\n\n".join(section.paragraphs))
+            raw = [full] if count_tokens(full) <= MAX_TOKENS else chunk_text_block(full, MAX_TOKENS)
+            if len(raw) > 1:
+                raw = add_overlap(raw, OVERLAP_RATIO)
+            capped = []
+            for rc in raw:
+                capped.extend(chunk_text_block(rc, MAX_TOKENS) if count_tokens(rc) > MAX_TOKENS + 50 else [rc])
+            for ct in capped:
+                if count_tokens(ct) < MIN_QUALITY_TOKENS:
+                    continue
+                ct = clean_ui_from_text(ct)
+                if not ct or count_tokens(ct) < MIN_QUALITY_TOKENS:
+                    continue
+                if (is_figure_axis_gibberish(ct) or is_digit_heavy_garbage(ct)
+                        or is_boilerplate_noise(ct) or is_affiliation_fragment(ct)
+                        or is_reference_block(ct) or has_repeating_loop(ct)):
+                    continue
+                h = hashlib.md5(ct.encode()).hexdigest()
+                if h in seen:
+                    continue
+                seen.add(h)
+                twp = make_prefix(product_id, title, doc_id, doc_type, section_path) + ct
+                out.append({
+                    "chunk_id": f"{product_id}__{doc_id}__{h[:12]}",
+                    "product_id": product_id, "product_title": title,
+                    "doc_id": doc_id, "doc_type": doc_type,
+                    "section_path": section_path, "section_name": section.name,
+                    "chunk_type": "text", "chunk_index": counter,
+                    "token_count": count_tokens(twp),
+                    "text_with_prefix": twp, "text_raw": ct,
+                })
+                counter += 1
+
+        # ── tables ──
+        for j, tbl in enumerate(section.tables):
+            tbl_text = tbl.get("text", "")
+            if not tbl_text or count_tokens(tbl_text) < 10:
+                continue
+            if is_noise_table(tbl_text):
+                continue
+            caption = section.captions[j] if j < len(section.captions) else ""
+            ctx = f"[TABLE in section: {section_path}]" + (f"\nCaption: {caption}" if caption else "")
+            if count_tokens(tbl_text) > TABLE_MAX_TOKENS:
+                kept, tok = [], 0
+                for tl in tbl_text.split("\n"):
+                    lt = count_tokens(tl)
+                    if tok + lt > TABLE_MAX_TOKENS - 20:
+                        break
+                    kept.append(tl); tok += lt
+                tbl_text = "\n".join(kept) + "\n[... TABLE TRUNCATED ...]"
+            body = ctx + "\n\n" + tbl_text
+            twp = make_prefix(product_id, title, doc_id, doc_type, section_path) + body
+            cid = hashlib.md5(f"{product_id}{doc_id}tbl{section_path}{j}".encode()).hexdigest()[:12]
+            out.append({
+                "chunk_id": f"{product_id}__{doc_id}__tbl_{cid}",
+                "product_id": product_id, "product_title": title,
+                "doc_id": doc_id, "doc_type": doc_type,
+                "section_path": section_path, "section_name": section.name,
+                "chunk_type": "table", "chunk_index": counter,
+                "token_count": count_tokens(twp),
+                "text_with_prefix": twp, "text_raw": body,
+            })
+            counter += 1
+
+    # merge tiny adjacent text chunks
+    merged: list[dict] = []
+    ii = 0
+    while ii < len(out):
+        c = out[ii]
+        if (c["token_count"] < MIN_TOKENS and c["chunk_type"] == "text"
+                and ii + 1 < len(out) and out[ii + 1]["section_path"] == c["section_path"]
+                and out[ii + 1]["chunk_type"] == "text"):
+            nxt = out[ii + 1]
+            mt = c["text_raw"] + "\n\n" + nxt["text_raw"]
+            nxt["text_raw"] = mt
+            nxt["text_with_prefix"] = nxt["text_with_prefix"].split("---\n", 1)[0] + "---\n" + mt
+            nxt["token_count"] = count_tokens(nxt["text_with_prefix"])
+            ii += 1
+        else:
+            merged.append(c); ii += 1
+    for i, c in enumerate(merged):
+        c["chunk_index"] = i
+    return merged
+
+
+def main() -> None:
+    catalog = json.loads((OUT / "catalog.json").read_text())
+    title_by_pid = {c["product_id"]: c["product_title"] for c in catalog}
+
+    # Prefer CLEANED markdown (clean_md.py output) over raw marine_parsed.
+    clean_dir = OUT / "cleaned"
+    use_clean = clean_dir.exists() and any(clean_dir.glob("*.md"))
+    if use_clean:
+        md_files = sorted(clean_dir.glob("*.md"))
+        print(f"source: CLEANED ({len(md_files)} files)")
+
+        def product_of(md: Path) -> str:
+            return md.stem.split("__", 1)[0]
+    else:
+        md_files = sorted(PARSED.rglob("vlm/*.md"))
+        print(f"source: RAW marine_parsed ({len(md_files)} files)")
+
+        def product_of(md: Path) -> str:
+            return md.relative_to(PARSED).parts[0]
+
+    out_path = OUT / "chunks.jsonl"
+    done_docs: set[str] = set()
+    if out_path.exists():
+        with open(out_path) as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    done_docs.add(f"{r['product_id']}__{r['doc_id']}")
+                except Exception:
+                    pass
+        print(f"resume: {len(done_docs)} docs already chunked")
+
+    n_docs = n_chunks = 0
+    with open(out_path, "a", encoding="utf-8") as fout:
+        for md in md_files:
+            pid = product_of(md)
+            doc_id = md.stem.split("__", 1)[1] if use_clean and "__" in md.stem else md.stem
+            doc_key = f"{pid}__{doc_id}"
+            if doc_key in done_docs:
+                continue
+            try:
+                chunks = chunk_marine_md(md, pid, title_by_pid.get(pid, ""), doc_id)
+            except Exception as e:
+                print(f"  ERROR {doc_key}: {repr(e)[:120]}", file=sys.stderr)
+                continue
+            for c in chunks:
+                fout.write(json.dumps(c, ensure_ascii=False) + "\n")
+            fout.flush()
+            n_docs += 1
+            n_chunks += len(chunks)
+            if n_docs % 50 == 0:
+                print(f"  [{n_docs} docs] {n_chunks} chunks")
+    print(f"DONE: {n_docs} docs newly chunked, {n_chunks} chunks → {out_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/clean_md.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+clean_md.py — Clean CMEMS VLM markdown BEFORE chunking (mirrors the cmip6
+preprocess step). For each marine_parsed doc:
+  - convert <table> HTML → markdown pipe tables (readable, chunker-detectable)
+  - drop image refs
+  - strip CMEMS boilerplate sections (CHANGE RECORD, TABLE OF CONTENTS,
+    LIST OF TABLES/FIGURES, ACRONYM TABLE, RELEVANT DOCUMENT LIST, REFERENCES…)
+  - strip running page header/footer lines (repeated >3× within the doc)
+  - strip TOC dotted-leader lines and cover preamble noise
+  - fix OCR-ris stripping, collapse blank lines
+
+Keeps the science: executive summary, products covered, accuracy, production
+system, validation framework/results, key definitions, system events.
+
+Output: out/cleaned/<product_id>__<doc_id>.md  (+ out/clean_stats.json)
+"""
+import json
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+WS = ROOT.parent
+PARSED = WS / "marine_parsed"
+OUT = ROOT / "out"
+CLEAN_DIR = OUT / "cleaned"
+sys.path.insert(0, "/Users/dmpantiu/cmip6/cmip6_gpt/rag")
+from preprocess_markdown import convert_html_table_to_markdown  # noqa: E402
+from chunk_papers import fix_ocr_ris_stripping  # noqa: E402
+
+# Section headers (normalised, no numbering) to drop entirely.
+STRIP_SECTIONS = {
+    "change record", "table of contents", "contents", "list of tables",
+    "list of figures", "list of acronyms", "acronym table", "acronyms",
+    "abbreviations", "references", "bibliography", "relevant document list",
+    "document history", "distribution list", "approval",
+    "list of tables and figures", "glossary",
+}
+# Standalone (non-#) all-caps label lines that precede a boilerplate table.
+LABEL_NOISE = {
+    "acronym table", "relevant document list", "list of acronyms",
+    "applicable documents", "reference documents",
+}
+# Cover/preamble noise lines.
+_preamble_re = re.compile(
+    r"^(issue|contributors?|approval date|approved by|prepared by|authors?|"
+    r"ref|date|version|nom du fichier|reference)\s*[:\.]", re.IGNORECASE)
+_toc_dotted_re = re.compile(r".*\.{3,}\s*\d+\s*$")        # "Change Record....2"
+_num_prefix_re = re.compile(r"^[\dIVXivx]+(\.[\dIVXivx]+)*\.?\s+")
+_img_re = re.compile(r"^!\[.*\]\(.*\)\s*$")
+_header_re = re.compile(r"^(#{1,6})\s+(.+?)\s*#*$")
+
+
+def norm_header(text: str) -> str:
+    t = _num_prefix_re.sub("", text.strip())
+    return t.lower().strip().rstrip(":.").strip()
+
+
+def convert_inline_tables(line: str) -> str:
+    """Replace every <table>…</table> on a line with a markdown table block."""
+    def repl(m):
+        return "\n" + convert_html_table_to_markdown(m.group(0)) + "\n"
+    return re.sub(r"<table>.*?</table>", repl, line, flags=re.DOTALL | re.IGNORECASE)
+
+
+def clean_md(md_text: str) -> str:
+    # 1) table conversion (do before line-splitting; tables are single-line here)
+    md_text = convert_inline_tables(md_text)
+    md_text = md_text.replace("\\_", "_")  # un-escape product ids etc.
+    lines = md_text.split("\n")
+
+    # 2) detect running header/footer lines (repeated >3×) to drop
+    norm = [re.sub(r"\s+", " ", l.strip()) for l in lines]
+    freq = Counter(n for n in norm if len(n) > 15)
+    repeated = {n for n, c in freq.items() if c > 3}
+
+    out, i, n = [], 0, len(lines)
+    skip_section = False
+    while i < n:
+        line = lines[i]
+        s = line.strip()
+        nm = re.sub(r"\s+", " ", s)
+
+        hm = _header_re.match(s)
+        if hm:
+            skip_section = norm_header(hm.group(2)) in STRIP_SECTIONS
+            if skip_section:
+                i += 1
+                continue
+            out.append(f"{hm.group(1)} {hm.group(2)}")
+            i += 1
+            continue
+        if skip_section:
+            i += 1
+            continue
+
+        # standalone label + following table/lines → drop until blank
+        if s.lower().rstrip(":. ") in LABEL_NOISE:
+            i += 1
+            while i < n and lines[i].strip() and not _header_re.match(lines[i].strip()):
+                i += 1
+            continue
+
+        if not s:
+            out.append("")
+            i += 1
+            continue
+        if _img_re.match(s) or _toc_dotted_re.match(s) or _preamble_re.match(s):
+            i += 1
+            continue
+        if len(nm) > 15 and nm in repeated:   # running header/footer
+            i += 1
+            continue
+        out.append(line)
+        i += 1
+
+    text = "\n".join(out)
+    text = fix_ocr_ris_stripping(text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text + "\n"
+
+
+def main() -> None:
+    CLEAN_DIR.mkdir(parents=True, exist_ok=True)
+    md_files = sorted(PARSED.rglob("vlm/*.md"))
+    stats = {"docs": 0, "orig_chars": 0, "clean_chars": 0}
+    for md in md_files:
+        pid = md.relative_to(PARSED).parts[0]
+        doc_id = md.stem
+        raw = md.read_text(encoding="utf-8", errors="replace")
+        try:
+            cleaned = clean_md(raw)
+        except Exception as e:
+            print(f"  ERR {pid}/{doc_id}: {repr(e)[:120]}", file=sys.stderr)
+            continue
+        (CLEAN_DIR / f"{pid}__{doc_id}.md").write_text(cleaned, encoding="utf-8")
+        stats["docs"] += 1
+        stats["orig_chars"] += len(raw)
+        stats["clean_chars"] += len(cleaned)
+        if stats["docs"] % 100 == 0:
+            print(f"  [{stats['docs']}] cleaned")
+    stats["reduction_pct"] = round(100 * (1 - stats["clean_chars"] / max(stats["orig_chars"], 1)), 1)
+    (OUT / "clean_stats.json").write_text(json.dumps(stats, indent=1))
+    print(json.dumps(stats, indent=1))
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/embed.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+embed.py — Embed marine doc chunks with Gemini Embedding 2 (locked model).
+
+Model: gemini-embedding-2-preview  (768-dim, L2-normalized, RETRIEVAL_DOCUMENT).
+No substitutes. Reranker is handled separately in search.py (Google Vertex Rank API).
+
+Key resolution order:
+  1. env GOOGLE_API_KEY
+  2. env GEMINI_API_KEY
+  3. vertex_api_key=... in /Users/dmpantiu/cmip6/cmip6_gpt/.env
+
+Modes:
+  realtime  — streaming API, resumable (default)
+  batch     — submit Batch API job (50% cost), then `status` / `download`
+  status    --resume <job>
+  download  --resume <job>
+
+Usage:
+  python embed.py --mode realtime
+  python embed.py --mode realtime --limit 20      # smoke test
+"""
+import argparse
+import json
+import math
+import os
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+import net_ipv4  # noqa: F401  — force IPv4 egress (VPN), must precede genai client
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+IN_JSONL = OUT / "chunks.jsonl"
+OUT_JSONL = OUT / "chunks_embedded.jsonl"
+BATCH_INPUT = OUT / "batch_embed_input.jsonl"
+
+MODEL = "gemini-embedding-2-preview"
+TASK_TYPE = "RETRIEVAL_DOCUMENT"
+OUTPUT_DIM = 768
+# AQ express key on gemini-embedding-2-preview is quota-capped at ~5 req/min.
+# Big batches (100 contents/req) + ~13s spacing keep us under the cap.
+RT_BATCH = 100
+RT_SLEEP = 13.0
+
+
+def resolve_key() -> str:
+    for var in ("GOOGLE_API_KEY", "GEMINI_API_KEY"):
+        if os.environ.get(var):
+            return os.environ[var]
+    # new key lives in copernicus_mcp/.env (field may be misspelled 'veretex_api_key')
+    for env in (Path("/Users/dmpantiu/copernicus_mcp/.env"),
+                Path("/Users/dmpantiu/cmip6/cmip6_gpt/.env")):
+        if env.exists():
+            for line in env.read_text().splitlines():
+                line = line.strip()
+                if "api_key" in line.lower() and "=" in line and not line.startswith("#"):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("No Gemini API key found (GOOGLE_API_KEY / vertex_api_key).")
+
+
+def get_client():
+    from google import genai
+    return genai.Client(api_key=resolve_key())
+
+
+def l2(vec):
+    a = np.array(vec, dtype=np.float32)
+    n = np.linalg.norm(a)
+    return (a / n).tolist() if n > 0 else a.tolist()
+
+
+def load_chunks(limit=None):
+    rows = []
+    with open(IN_JSONL) as f:
+        for i, line in enumerate(f):
+            if limit and i >= limit:
+                break
+            rows.append(json.loads(line))
+    return rows
+
+
+def embed_realtime(chunks):
+    from google.genai import types
+    client = get_client()
+    done = set()
+    if OUT_JSONL.exists():
+        for line in open(OUT_JSONL):
+            try:
+                done.add(json.loads(line)["chunk_id"])
+            except Exception:
+                pass
+        print(f"resume: {len(done)} already embedded")
+    todo = [c for c in chunks if c["chunk_id"] not in done]
+    print(f"to embed: {len(todo)} / {len(chunks)}")
+    n = 0
+    with open(OUT_JSONL, "a", encoding="utf-8") as fout:
+        for b in range(0, len(todo), RT_BATCH):
+            batch = todo[b:b + RT_BATCH]
+            texts = [c["text_with_prefix"] for c in batch]
+            for attempt in range(6):
+                try:
+                    # genai 1.64 can raise "client has been closed" — recreate on retry
+                    if attempt > 0:
+                        client = get_client()
+                    r = client.models.embed_content(
+                        model=MODEL, contents=texts,
+                        config=types.EmbedContentConfig(
+                            task_type=TASK_TYPE, output_dimensionality=OUTPUT_DIM),
+                    )
+                    for c, e in zip(batch, r.embeddings):
+                        c["embedding"] = l2(e.values)
+                        fout.write(json.dumps(c, ensure_ascii=False) + "\n")
+                        n += 1
+                    fout.flush()
+                    break
+                except Exception as e:
+                    es = str(e)
+                    if "IP address restriction" in es:
+                        raise SystemExit(
+                            "BLOCKED: Gemini key has IP restriction. Whitelist this host's "
+                            "IP in Google Cloud Console (API key settings) and re-run.")
+                    if any(k in es for k in ("429", "RESOURCE_EXHAUSTED", "Quota exceeded")):
+                        wait = 35            # ~5 RPM quota — wait out the minute window
+                    elif "client has been closed" in es:
+                        wait = 2             # flaky genai transport; client recreated on retry
+                    else:
+                        wait = min(8 * (2 ** attempt), 60)
+                    print(f"  retry {attempt+1}/8 in {wait}s: {repr(e)[:120]}", file=sys.stderr)
+                    time.sleep(wait)
+            else:
+                print(f"  FATAL skip {len(batch)}", file=sys.stderr)
+            if n % 400 == 0:
+                print(f"  [{n}/{len(todo)}]")
+            time.sleep(RT_SLEEP)
+    print(f"DONE: {n} embedded → {OUT_JSONL}")
+
+
+JOB_FILE = OUT / "batch_job.txt"
+
+
+def prepare_batch(chunks):
+    # Correct batch schema: request.content (singular) + flat task_type/output_dimensionality.
+    with open(BATCH_INPUT, "w", encoding="utf-8") as f:
+        for c in chunks:
+            f.write(json.dumps({
+                "key": c["chunk_id"],
+                "request": {
+                    "content": {"parts": [{"text": c["text_with_prefix"]}]},
+                    "task_type": TASK_TYPE,
+                    "output_dimensionality": OUTPUT_DIM,
+                },
+            }, ensure_ascii=False) + "\n")
+    print(f"batch input: {BATCH_INPUT} ({BATCH_INPUT.stat().st_size/1e6:.1f} MB, {len(chunks)} reqs)")
+
+
+def submit_batch():
+    client = get_client()
+    up = client.files.upload(file=str(BATCH_INPUT),
+                             config={"display_name": "marine_embed_input", "mime_type": "jsonl"})
+    job = client.batches.create_embeddings(
+        model=MODEL, src={"file_name": up.name},
+        config={"display_name": "marine_docs_embeddings"})
+    JOB_FILE.write_text(job.name)
+    print(f"job: {job.name}  state: {job.state}  (saved to {JOB_FILE})")
+    return job.name
+
+
+def _extract_values(resp: dict):
+    """Pull the embedding vector out of a batch result line, shape-tolerant."""
+    for path in (("response", "embeddings"), ("response", "embedding"), ("embeddings",), ("embedding",)):
+        node = resp
+        ok = True
+        for k in path:
+            if isinstance(node, dict) and k in node:
+                node = node[k]
+            else:
+                ok = False
+                break
+        if not ok:
+            continue
+        if isinstance(node, list) and node and isinstance(node[0], dict) and "values" in node[0]:
+            return node[0]["values"]
+        if isinstance(node, dict) and "values" in node:
+            return node["values"]
+    return None
+
+
+def poll_and_download(chunks, wait=True):
+    client = get_client()
+    name = JOB_FILE.read_text().strip()
+    while True:
+        job = client.batches.get(name=name)
+        state = str(job.state)
+        print(f"  job {name}: {state}")
+        if "SUCCEEDED" in state or "FAILED" in state or "CANCELLED" in state or "EXPIRED" in state:
+            break
+        if not wait:
+            return False
+        time.sleep(30)
+    if "SUCCEEDED" not in state:
+        print(f"job not successful: {state}")
+        return False
+
+    by_key = {c["chunk_id"]: c for c in chunks}
+    dest = getattr(job, "dest", None)
+    fn = getattr(dest, "file_name", None) if dest else None
+    lines = []
+    if fn:
+        lines = client.files.download(file=fn).decode("utf-8").strip().split("\n")
+    elif dest and getattr(dest, "inlined_responses", None):
+        lines = [json.dumps(r) for r in dest.inlined_responses]
+    n = 0
+    with open(OUT_JSONL, "w", encoding="utf-8") as fout:
+        for line in lines:
+            if not line.strip():
+                continue
+            r = json.loads(line)
+            k = r.get("key") or r.get("custom_metadata") or r.get("custom_id")
+            vals = _extract_values(r)
+            if k in by_key and vals:
+                c = dict(by_key[k])
+                c["embedding"] = l2(vals)
+                fout.write(json.dumps(c, ensure_ascii=False) + "\n")
+                n += 1
+    print(f"DOWNLOADED: {n}/{len(chunks)} embeddings → {OUT_JSONL}")
+    return n >= len(chunks) * 0.99
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", choices=["realtime", "batch", "submit", "poll", "status", "download"],
+                    default="realtime")
+    ap.add_argument("--limit", type=int, default=None)
+    ap.add_argument("--resume", type=str, default=None)
+    a = ap.parse_args()
+
+    chunks = load_chunks(a.limit)
+    toks = sum(c["token_count"] for c in chunks)
+    print(f"chunks={len(chunks):,} tokens={toks:,} "
+          f"est realtime=${toks/1e6*0.25:.2f} batch=${toks/1e6*0.125:.2f}")
+
+    if a.mode == "realtime":
+        embed_realtime(chunks)
+    elif a.mode in ("batch", "submit"):
+        prepare_batch(chunks)
+        submit_batch()
+        if a.mode == "batch":
+            poll_and_download(chunks, wait=True)
+    elif a.mode == "poll":
+        poll_and_download(chunks, wait=True)
+    elif a.mode in ("status", "download"):
+        client = get_client()
+        name = a.resume or JOB_FILE.read_text().strip()
+        job = client.batches.get(name=name)
+        print(f"state: {job.state}")
+        if a.mode == "download":
+            poll_and_download(chunks, wait=False)
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/embed_cds_batch.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+embed_cds_batch.py — embed the 164 CDS/ADS/EWDS cards via the Gemini Batch API
+(free-tier realtime RPM is ~0 on gemini-embedding-2-preview; batch works).
+
+Autonomous: submit → poll every 60s → download → then the caller runs
+load_copernicus_docs.py + verify. Writes out/cds_cards_embedded.jsonl and a
+marker out/CDS_EMBED_DONE on success.
+"""
+import json
+import time
+import sys
+from pathlib import Path
+
+import net_ipv4  # noqa: F401
+from embed import resolve_key, l2, MODEL, TASK_TYPE, OUTPUT_DIM, _extract_values
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+IN_JSONL = OUT / "cds_cards_chunks.jsonl"
+OUT_JSONL = OUT / "cds_cards_embedded.jsonl"
+BATCH_INPUT = OUT / "cds_batch_input.jsonl"
+JOB_FILE = OUT / "cds_batch_job.txt"
+DONE = OUT / "CDS_EMBED_DONE"
+
+
+def get_client():
+    from google import genai
+    return genai.Client(api_key=resolve_key())
+
+
+def prepare(chunks):
+    with open(BATCH_INPUT, "w", encoding="utf-8") as f:
+        for c in chunks:
+            f.write(json.dumps({
+                "key": c["chunk_id"],
+                "request": {
+                    "content": {"parts": [{"text": c["text_with_prefix"]}]},
+                    "task_type": TASK_TYPE,
+                    "output_dimensionality": OUTPUT_DIM,
+                },
+            }, ensure_ascii=False) + "\n")
+    print(f"batch input: {BATCH_INPUT} ({len(chunks)} reqs)", flush=True)
+
+
+def submit():
+    client = get_client()
+    up = client.files.upload(file=str(BATCH_INPUT),
+                             config={"display_name": "cds_cards_input", "mime_type": "jsonl"})
+    job = client.batches.create_embeddings(
+        model=MODEL, src={"file_name": up.name},
+        config={"display_name": "copernicus_cds_cards"})
+    JOB_FILE.write_text(job.name)
+    print(f"job: {job.name}  state: {job.state}", flush=True)
+    return job.name
+
+
+def poll_download(chunks):
+    client = get_client()
+    name = JOB_FILE.read_text().strip()
+    while True:
+        job = client.batches.get(name=name)
+        state = str(job.state)
+        print(f"  {name}: {state}", flush=True)
+        if any(s in state for s in ("SUCCEEDED", "FAILED", "CANCELLED", "EXPIRED")):
+            break
+        time.sleep(60)
+    if "SUCCEEDED" not in state:
+        print(f"job not successful: {state}", flush=True)
+        return 0
+    by_key = {c["chunk_id"]: c for c in chunks}
+    dest = getattr(job, "dest", None)
+    fn = getattr(dest, "file_name", None) if dest else None
+    lines = []
+    if fn:
+        lines = client.files.download(file=fn).decode("utf-8").strip().split("\n")
+    elif dest and getattr(dest, "inlined_responses", None):
+        lines = [json.dumps(r) for r in dest.inlined_responses]
+    n = 0
+    with open(OUT_JSONL, "w", encoding="utf-8") as fout:
+        for line in lines:
+            if not line.strip():
+                continue
+            r = json.loads(line)
+            k = r.get("key") or r.get("custom_id")
+            vals = _extract_values(r)
+            if k in by_key and vals:
+                c = dict(by_key[k])
+                c["embedding"] = l2(vals)
+                fout.write(json.dumps(c, ensure_ascii=False) + "\n")
+                n += 1
+    print(f"DOWNLOADED: {n}/{len(chunks)} → {OUT_JSONL}", flush=True)
+    if n >= len(chunks) * 0.99:
+        DONE.write_text(f"{n}/{len(chunks)}")
+    return n
+
+
+def main():
+    chunks = [json.loads(l) for l in open(IN_JSONL)]
+    resume = "--poll" in sys.argv and JOB_FILE.exists()
+    if not resume:
+        prepare(chunks)
+        submit()
+    poll_download(chunks)
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/embed_cds_cards.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+embed_cds_cards.py — embed the 164 CDS/ADS/EWDS cards with the locked model
+(gemini-embedding-2-preview, 768-dim, L2). Realtime mode, resumable.
+Reuses embed.py's key resolution + IPv4 egress + L2 norm.
+"""
+import json
+import time
+import sys
+from pathlib import Path
+
+import net_ipv4  # noqa: F401 — force IPv4 egress before genai client
+from embed import resolve_key, l2, MODEL, TASK_TYPE, OUTPUT_DIM
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+IN_JSONL = OUT / "cds_cards_chunks.jsonl"
+OUT_JSONL = OUT / "cds_cards_embedded.jsonl"
+
+RT_BATCH = 50   # 164 cards / 50 ≈ 4 requests
+RT_SLEEP = 13.0
+
+
+def get_client():
+    from google import genai
+    return genai.Client(api_key=resolve_key())
+
+
+def main():
+    from google.genai import types
+    chunks = [json.loads(l) for l in open(IN_JSONL)]
+    done = set()
+    if OUT_JSONL.exists():
+        for line in open(OUT_JSONL):
+            try:
+                done.add(json.loads(line)["chunk_id"])
+            except Exception:
+                pass
+    todo = [c for c in chunks if c["chunk_id"] not in done]
+    print(f"to embed: {len(todo)} / {len(chunks)} ({len(done)} already done)")
+    client = get_client()
+    n = 0
+    with open(OUT_JSONL, "a", encoding="utf-8") as fout:
+        for b in range(0, len(todo), RT_BATCH):
+            batch = todo[b:b + RT_BATCH]
+            texts = [c["text_with_prefix"] for c in batch]
+            for attempt in range(8):
+                try:
+                    if attempt > 0:
+                        client = get_client()
+                    r = client.models.embed_content(
+                        model=MODEL, contents=texts,
+                        config=types.EmbedContentConfig(
+                            task_type=TASK_TYPE, output_dimensionality=OUTPUT_DIM))
+                    for c, e in zip(batch, r.embeddings):
+                        c["embedding"] = l2(e.values)
+                        fout.write(json.dumps(c, ensure_ascii=False) + "\n")
+                        n += 1
+                    fout.flush()
+                    print(f"  [{n}/{len(todo)}]")
+                    break
+                except Exception as e:
+                    es = str(e)
+                    if "IP address restriction" in es:
+                        raise SystemExit("BLOCKED: Gemini key IP restriction.")
+                    if any(k in es for k in ("429", "RESOURCE_EXHAUSTED", "Quota exceeded")):
+                        wait = 35
+                    elif "client has been closed" in es:
+                        wait = 2
+                    else:
+                        wait = min(8 * (2 ** attempt), 60)
+                    print(f"  retry {attempt+1}/8 in {wait}s: {repr(e)[:120]}", file=sys.stderr)
+                    time.sleep(wait)
+            else:
+                print(f"  FATAL skip {len(batch)}", file=sys.stderr)
+            time.sleep(RT_SLEEP)
+    print(f"DONE: {n} embedded → {OUT_JSONL}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/load_copernicus_docs.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+load_copernicus_docs.py — build the unified `copernicus_docs` Qdrant collection:
+one metadata card per dataset across ALL four Copernicus stores (~1415).
+
+  - 164 CDS/ADS/EWDS cards from out/cds_cards_embedded.jsonl  (store=CDS/ADS/EWDS)
+  - 1251 Marine dataset cards, reusing the already-embedded CARD chunks in
+    out/chunks_embedded.jsonl                                  (store=CMEMS)
+
+Dense (768-dim Cosine, gemini-embedding-2-preview) + sparse (BM25) hybrid,
+same recipe as marine_docs. Adds a `store` payload keyword for per-store filtering.
+The deep Marine PUM/QUID/SQO doc-RAG (marine_docs) is left untouched.
+"""
+import json
+import time
+import uuid
+from pathlib import Path
+
+from qdrant_client import QdrantClient, models
+from fastembed import SparseTextEmbedding
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+COLLECTION = "copernicus_docs"
+DENSE_DIM = 768
+LOCAL_DB = OUT / "qdrant_db"
+CDS_EMB = OUT / "cds_cards_embedded.jsonl"
+MARINE_EMB = OUT / "chunks_embedded.jsonl"
+BATCH = 400
+
+_bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+
+
+def to_sparse(text: str) -> models.SparseVector:
+    r = list(_bm25.embed([text]))[0]
+    return models.SparseVector(indices=r.indices.tolist(), values=r.values.tolist())
+
+
+def iter_cards():
+    """Yield (chunk, store) for every dataset card to index."""
+    # CDS/ADS/EWDS — each row already carries a `store` field
+    for line in open(CDS_EMB, encoding="utf-8"):
+        c = json.loads(line)
+        if c.get("embedding"):
+            yield c, c.get("store", "CDS")
+    # Marine — reuse CARD chunks only, tag store=CMEMS
+    seen = set()
+    for line in open(MARINE_EMB, encoding="utf-8"):
+        c = json.loads(line)
+        if c.get("doc_type") != "CARD" or not c.get("embedding"):
+            continue
+        if c["chunk_id"] in seen:
+            continue
+        seen.add(c["chunk_id"])
+        yield c, "CMEMS"
+
+
+def create_collection(client: QdrantClient) -> None:
+    names = [c.name for c in client.get_collections().collections]
+    if COLLECTION in names:
+        client.delete_collection(COLLECTION)
+    client.create_collection(
+        collection_name=COLLECTION,
+        vectors_config={"dense": models.VectorParams(size=DENSE_DIM, distance=models.Distance.COSINE)},
+        sparse_vectors_config={"sparse": models.SparseVectorParams(modifier=models.Modifier.IDF)},
+    )
+    for field in ("product_id", "doc_type", "store"):
+        client.create_payload_index(collection_name=COLLECTION, field_name=field,
+                                    field_schema=models.PayloadSchemaType.KEYWORD)
+    print(f"created '{COLLECTION}' (dense+sparse, 3 payload indexes)")
+
+
+def load(client: QdrantClient) -> None:
+    buf, total, t0 = [], 0, time.time()
+    per_store = {}
+    for c, store in iter_cards():
+        per_store[store] = per_store.get(store, 0) + 1
+        raw = c.get("text_raw", c.get("text_with_prefix", ""))
+        buf.append(models.PointStruct(
+            id=str(uuid.uuid5(uuid.NAMESPACE_DNS, c["chunk_id"])),
+            vector={"dense": c["embedding"], "sparse": to_sparse(raw)},
+            payload={
+                "chunk_id": c["chunk_id"],
+                "product_id": c["product_id"],
+                "product_title": c.get("product_title", ""),
+                "dataset_id": c.get("doc_id", c["product_id"]),
+                "doc_type": c.get("doc_type", "CARD"),
+                "chunk_type": c.get("chunk_type", "card"),
+                "store": store,
+                "text_raw": raw[:2500],
+            },
+        ))
+        if len(buf) >= BATCH:
+            client.upsert(collection_name=COLLECTION, points=buf)
+            total += len(buf); buf = []
+            print(f"  [{total:,}] {total/(time.time()-t0):.0f} pts/s")
+    if buf:
+        client.upsert(collection_name=COLLECTION, points=buf)
+        total += len(buf)
+    print(f"DONE: {total:,} points | per store: {per_store} | "
+          f"collection now {client.get_collection(COLLECTION).points_count:,}")
+
+
+def main():
+    client = QdrantClient(path=str(LOCAL_DB))
+    print(f"Qdrant local: {LOCAL_DB}")
+    create_collection(client)
+    load(client)
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/load_qdrant.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+load_qdrant.py — Load embedded marine doc chunks into Qdrant (hybrid).
+
+Collection `marine_docs`:
+  - dense  (768-dim, Cosine) from gemini-embedding-2-preview
+  - sparse (BM25 via FastEmbed) for keyword search
+  - payload indexes: product_id, doc_type, chunk_type, section_path
+
+Storage: local persistent Qdrant at out/qdrant_db by default (no server needed);
+pass --url http://localhost:6333 to use a server instead.
+
+Usage:
+  python load_qdrant.py --recreate
+  python load_qdrant.py --limit 500
+"""
+import argparse
+import json
+import time
+import uuid
+from pathlib import Path
+
+from qdrant_client import QdrantClient, models
+from fastembed import SparseTextEmbedding
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+COLLECTION = "marine_docs"
+DENSE_DIM = 768
+INPUT = OUT / "chunks_embedded.jsonl"
+LOCAL_DB = OUT / "qdrant_db"
+BATCH = 500
+
+_bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+
+
+def to_sparse(text: str) -> models.SparseVector:
+    r = list(_bm25.embed([text]))[0]
+    return models.SparseVector(indices=r.indices.tolist(), values=r.values.tolist())
+
+
+def create_collection(client: QdrantClient, recreate: bool) -> None:
+    names = [c.name for c in client.get_collections().collections]
+    if COLLECTION in names:
+        if recreate:
+            client.delete_collection(COLLECTION)
+        else:
+            print(f"'{COLLECTION}' exists: {client.get_collection(COLLECTION).points_count} pts")
+            return
+    client.create_collection(
+        collection_name=COLLECTION,
+        vectors_config={"dense": models.VectorParams(size=DENSE_DIM, distance=models.Distance.COSINE)},
+        sparse_vectors_config={"sparse": models.SparseVectorParams(modifier=models.Modifier.IDF)},
+    )
+    for field, schema in [
+        ("product_id", models.PayloadSchemaType.KEYWORD),
+        ("doc_type", models.PayloadSchemaType.KEYWORD),
+        ("chunk_type", models.PayloadSchemaType.KEYWORD),
+        ("section_path", models.PayloadSchemaType.KEYWORD),
+    ]:
+        client.create_payload_index(collection_name=COLLECTION, field_name=field, field_schema=schema)
+    print(f"created '{COLLECTION}' (dense+sparse, 4 payload indexes)")
+
+
+def load(client: QdrantClient, limit=None) -> None:
+    buf, total, skipped, t0 = [], 0, 0, time.time()
+    with open(INPUT, encoding="utf-8") as f:
+        for i, line in enumerate(f):
+            if limit and i >= limit:
+                break
+            c = json.loads(line)
+            emb = c.get("embedding")
+            if not emb:
+                skipped += 1
+                continue
+            raw = c.get("text_raw", c.get("text_with_prefix", ""))
+            buf.append(models.PointStruct(
+                id=str(uuid.uuid5(uuid.NAMESPACE_DNS, c["chunk_id"])),
+                vector={"dense": emb, "sparse": to_sparse(raw)},
+                payload={
+                    "chunk_id": c["chunk_id"], "product_id": c["product_id"],
+                    "product_title": c.get("product_title", ""),
+                    "doc_id": c["doc_id"], "doc_type": c["doc_type"],
+                    "section_path": c.get("section_path", ""),
+                    "chunk_type": c.get("chunk_type", "text"),
+                    "text_raw": raw[:2500],
+                },
+            ))
+            if len(buf) >= BATCH:
+                client.upsert(collection_name=COLLECTION, points=buf)
+                total += len(buf)
+                print(f"  [{total:,}] {total/(time.time()-t0):.0f} pts/s")
+                buf = []
+    if buf:
+        client.upsert(collection_name=COLLECTION, points=buf)
+        total += len(buf)
+    print(f"DONE: {total:,} points, skipped {skipped}, total now "
+          f"{client.get_collection(COLLECTION).points_count:,}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--limit", type=int, default=None)
+    ap.add_argument("--recreate", action="store_true")
+    ap.add_argument("--url", type=str, default=None, help="Qdrant server URL; default = local path mode")
+    a = ap.parse_args()
+    client = QdrantClient(url=a.url, check_compatibility=False) if a.url else QdrantClient(path=str(LOCAL_DB))
+    print(f"Qdrant: {'server '+a.url if a.url else 'local '+str(LOCAL_DB)}")
+    create_collection(client, a.recreate)
+    load(client, a.limit)
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/net_ipv4.py

@@ -0,0 +1,18 @@
+"""Force all outbound DNS resolution to IPv4 so requests egress through the
+IPv4 VPN instead of leaking onto native IPv6 (which bypasses the VPN and trips
+the Gemini key's IP whitelist). Import this module before creating any client.
+
+Disable with env FORCE_IPV4=0.
+"""
+import os
+import socket
+
+if os.environ.get("FORCE_IPV4", "1") != "0":
+    _orig = socket.getaddrinfo
+
+    def _v4_only(host, *args, **kwargs):
+        res = _orig(host, *args, **kwargs)
+        v4 = [r for r in res if r[0] == socket.AF_INET]
+        return v4 or res  # fall back to original if no v4 (don't break localhost)
+
+    socket.getaddrinfo = _v4_only

scripts/marine_rag/rag_api.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+rag_api.py — the callable RAG layer the MCP server exposes "through MCP".
+
+Given a dataset OR product id (and optional question), return the relevant
+documentation chunks (PUM/QUID/SQO) so the agent knows how to analyze the
+dataset before working with it.
+
+Public API:
+  resolve_product(dataset_or_product_id) -> product_id | None
+  get_dataset_docs(id, query=None, top_k=8, rerank=False) -> dict
+      {product_id, matched_by, results:[{doc_type, section, text, score}], ...}
+
+Backed by Qdrant (dense Gemini + BM25) built by load_qdrant.py; embeddings from
+gemini-embedding-2-preview; optional Google semantic-ranker rerank (search.py).
+Returns descriptors/text only — no raw scientific bytes (MCP large-data rule).
+"""
+import json
+from functools import lru_cache
+from pathlib import Path
+
+import search as S  # hybrid(), rerank_google(), get_client(), COLLECTION
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+
+
+@lru_cache(maxsize=1)
+def _catalog():
+    cat = json.loads((OUT / "catalog.json").read_text())
+    by_pid = {c["product_id"]: c for c in cat}
+    ds_to_pid = {}
+    for c in cat:
+        for ds in c.get("dataset_ids", []):
+            ds_to_pid[ds] = c["product_id"]
+            ds_to_pid[ds.lower()] = c["product_id"]
+    return by_pid, ds_to_pid
+
+
+def resolve_product(any_id: str) -> str | None:
+    by_pid, ds_to_pid = _catalog()
+    if any_id in by_pid:
+        return any_id
+    if any_id in ds_to_pid:
+        return ds_to_pid[any_id]
+    low = any_id.lower()
+    if low in ds_to_pid:
+        return ds_to_pid[low]
+    # prefix / containment fallback
+    for pid in by_pid:
+        if pid.lower() == low or low in pid.lower():
+            return pid
+    return None
+
+
+def get_dataset_docs(any_id: str, query: str | None = None,
+                     top_k: int = 8, rerank: bool = False, url: str | None = None) -> dict:
+    pid = resolve_product(any_id)
+    if not pid:
+        return {"ok": False, "error": f"unknown dataset/product id: {any_id}",
+                "hint": "use a CMEMS product_id or dataset_id from marine_search_*"}
+    by_pid, _ = _catalog()
+    prod = by_pid[pid]
+    client = S.get_client(url)
+
+    # Default question surfaces the "how to analyze" essentials.
+    q = query or (f"{prod['product_title']} variables, spatial and temporal coverage, "
+                  f"accuracy, validation, how to use and interpret this product")
+    points = S.hybrid(client, q, top_k=top_k, prefetch=40, product_id=pid)
+    if rerank:
+        rr = S.rerank_google(q, points, top_k)
+        if rr is not None:
+            points = rr
+    results = []
+    for p in points[:top_k]:
+        pl = p.payload
+        results.append({
+            "doc_type": pl.get("doc_type"),
+            "doc_id": pl.get("doc_id"),
+            "section": pl.get("section_path"),
+            "text": pl.get("text_raw"),
+            "score": getattr(p, "score", None),
+        })
+    return {
+        "ok": True,
+        "product_id": pid,
+        "product_title": prod["product_title"],
+        "matched_by": "product_id" if any_id == pid else "dataset_id/fuzzy",
+        "doc_types_available": prod.get("doc_types", []),
+        "dataset_ids": prod.get("dataset_ids", []),
+        "query": q,
+        "n_results": len(results),
+        "results": results,
+    }
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("id")
+    ap.add_argument("--query", default=None)
+    ap.add_argument("--top-k", type=int, default=6)
+    ap.add_argument("--rerank", action="store_true")
+    a = ap.parse_args()
+    out = get_dataset_docs(a.id, a.query, a.top_k, a.rerank)
+    # trim long result text for CLI readability without breaking JSON validity
+    for r in out.get("results", []):
+        if r.get("text") and len(r["text"]) > 400:
+            r["text"] = r["text"][:400] + "…"
+    print(json.dumps(out, ensure_ascii=False, indent=1))

scripts/marine_rag/rag_server.py

@@ -0,0 +1,1026 @@
+#!/usr/bin/env python3
+"""
+rag_server.py — `copernicus-rag` MCP server: RAG discovery + documentation layer
+for Copernicus data, companion to the `copernicus` MCP server (which does the
+actual subsetting/downloading).
+
+Two-level flow:
+  L0  search_datasets      — find datasets by meaning across ALL 4 stores
+                             (CMEMS 1251 + CDS 136 + ADS 16 + EWDS 12 cards)
+  L1  get_dataset_docs     — quality/EQC documentation (PUM/QUID/SQO) chunks
+                             for a CMEMS product, semantically filtered
+      search_docs          — same 29k doc chunks, searched globally
+      list_dataset_documents / read_document — pull full doc markdown
+
+Retrieval: Qdrant (embedded, out/qdrant_db) hybrid dense+BM25 with RRF fusion.
+Dense query vector = gemini-embedding-2-preview (768-dim); if the embed call
+fails (quota/net), we degrade to sparse-only BM25 and say so in the response.
+Optional Google semantic-ranker rerank when GCP_PROJECT + ADC are set.
+
+Invariants (mirrors copernicus-mcp): text/descriptors only — no raw scientific
+bytes; logging to stderr only; tools never raise — they return {"ok": false}.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import sys
+import threading
+from functools import lru_cache
+from pathlib import Path
+
+# stdio transport: stdout is the JSON-RPC channel — pin ALL logging to stderr
+# before any library gets a chance to install a stdout handler.
+logging.basicConfig(level=logging.WARNING, stream=sys.stderr, force=True)
+for _name in ("httpx", "httpcore", "google", "google_genai", "fastembed", "qdrant_client"):
+    logging.getLogger(_name).setLevel(logging.WARNING)
+
+ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT))
+
+import net_ipv4  # noqa: F401  — force IPv4 egress (VPN) before any genai call
+
+from mcp.server.fastmcp import FastMCP
+from qdrant_client import QdrantClient, models
+
+import search as S  # embed_query, sparse_query, rerank_google, LOCAL_DB
+
+OUT = ROOT / "out"
+CARDS_COLLECTION = "copernicus_docs"   # 1 card per dataset, all 4 stores
+DOCS_COLLECTION = "marine_docs"        # PUM/QUID/SQO chunks, CMEMS only
+STORES = ("CMEMS", "CDS", "ADS", "EWDS")
+DOC_TYPES = ("PUM", "QUID", "SQO", "CARD")
+MAX_TEXT = 1600          # per-chunk text cap in tool output
+READ_DEFAULT = 20_000    # default read_document window
+
+PUBS_DB = ROOT.parent / "pubs_rag" / "qdrant_db"
+PUBS_COLLECTION = "publications"
+REGISTRY = ROOT.parent / "publications" / "registry" / "publications.jsonl"
+PAPERS = ROOT.parent / "pubs_rag" / "out" / "papers.jsonl"
+LINKS_SIDECAR = ROOT.parent / "pubs_rag" / "out" / "links_by_dataset.json"
+PUB_DOMAINS = ("ocean/marine", "atmosphere", "cryosphere", "land",
+               "climate-modeling", "climate-general", "emergency")
+
+EQC_QA_DB = ROOT.parent / "eqc_qa" / "qdrant_db"
+EQC_QA_COLLECTION = "eqc_qa"
+
+# Deep documentation for the non-marine stores (CDS/ADS/EWDS): Confluence user
+# guides / ATBDs / PDFs, chunked like marine_docs. Separate DB (own lock).
+DEEP_DB = ROOT.parent / "deep_docs" / "qdrant_db"
+DEEP_COLLECTION = "cds_docs"
+
+# Notebook code layer: runnable example-notebook code ATTACHED to datasets
+# (serve-time join by dataset id — NOT embedded/searched on its own).
+NOTEBOOKS_SIDECAR = ROOT.parent / "eqc_qa" / "notebooks_by_dataset.json"
+
+_lock = threading.Lock()
+_client: QdrantClient | None = None
+_pubs_client: QdrantClient | None = None
+_eqc_client: QdrantClient | None = None
+_deep_client: QdrantClient | None = None
+
+
+def _log(msg: str) -> None:
+    print(f"[copernicus-rag] {msg}", file=sys.stderr, flush=True)
+
+
+def _qdrant() -> QdrantClient:
+    global _client
+    with _lock:
+        if _client is None:
+            _log(f"opening embedded Qdrant at {S.LOCAL_DB}")
+            try:
+                _client = QdrantClient(path=str(S.LOCAL_DB))
+            except Exception as e:
+                raise RuntimeError(
+                    "cannot open marine index (locked by a load script or another "
+                    f"server instance? retry when it finishes): {repr(e)[:120]}") from e
+        return _client
+
+
+@lru_cache(maxsize=1)
+def _catalog():
+    """CMEMS product catalog: by product_id + dataset_id -> product_id map."""
+    cat = json.loads((OUT / "catalog.json").read_text())
+    by_pid = {c["product_id"]: c for c in cat}
+    ds_to_pid = {}
+    for c in cat:
+        for ds in c.get("dataset_ids", []):
+            ds_to_pid[ds.lower()] = c["product_id"]
+    return by_pid, ds_to_pid
+
+
+def resolve_product(any_id: str) -> str | None:
+    """Exact product/dataset id, else UNIQUE prefix, else UNIQUE substring.
+
+    Ambiguous fragments (e.g. "006" is contained in 13 product ids) return
+    None instead of silently picking an arbitrary product.
+    """
+    by_pid, ds_to_pid = _catalog()
+    if any_id in by_pid:
+        return any_id
+    low = any_id.lower()
+    if not low:
+        return None
+    if low in ds_to_pid:
+        return ds_to_pid[low]
+    exact = [pid for pid in by_pid if pid.lower() == low]
+    if exact:
+        return exact[0]
+    starts = [pid for pid in by_pid if pid.lower().startswith(low)]
+    if len(starts) == 1:
+        return starts[0]
+    contains = starts or [pid for pid in by_pid if low in pid.lower()]
+    return contains[0] if len(contains) == 1 else None
+
+
+def _pubs_qdrant() -> QdrantClient | None:
+    """Client for the separate publications DB; None until the index is built."""
+    global _pubs_client
+    with _lock:
+        if _pubs_client is None:
+            if not PUBS_DB.exists():
+                return None
+            _log(f"opening embedded Qdrant at {PUBS_DB}")
+            try:
+                _pubs_client = QdrantClient(path=str(PUBS_DB))
+            except Exception as e:
+                raise RuntimeError(
+                    "cannot open publications index (locked by load_pubs_qdrant.py "
+                    f"or another server instance? retry when it finishes): {repr(e)[:120]}") from e
+        return _pubs_client
+
+
+def _pubs_status() -> str:
+    """Human-readable build status of the publications index."""
+    return ("publications index not on disk yet — PDFs are being downloaded "
+            "and VLM-parsed; the collection grows as parses land")
+
+
+def _eqc_qdrant() -> QdrantClient | None:
+    """Client for the CDS/C3S EQC quality-assessment DB; None until built."""
+    global _eqc_client
+    with _lock:
+        if _eqc_client is None:
+            if not EQC_QA_DB.exists():
+                return None
+            _log(f"opening embedded Qdrant at {EQC_QA_DB}")
+            try:
+                _eqc_client = QdrantClient(path=str(EQC_QA_DB))
+            except Exception as e:
+                raise RuntimeError(
+                    "cannot open EQC-QA index (locked by load_eqc_qa.py or another "
+                    f"server instance? retry when it finishes): {repr(e)[:120]}") from e
+        return _eqc_client
+
+
+def _deep_qdrant() -> QdrantClient | None:
+    """Client for the CDS/ADS/EWDS deep-docs DB; None until built."""
+    global _deep_client
+    with _lock:
+        if _deep_client is None:
+            if not DEEP_DB.exists():
+                return None
+            _log(f"opening embedded Qdrant at {DEEP_DB}")
+            try:
+                _deep_client = QdrantClient(path=str(DEEP_DB))
+            except Exception as e:
+                raise RuntimeError(
+                    "cannot open deep-docs index (locked by embed_load.py or another "
+                    f"server instance? retry when it finishes): {repr(e)[:120]}") from e
+        return _deep_client
+
+
+@lru_cache(maxsize=1)
+def _notebooks() -> tuple[dict, dict, dict]:
+    """Notebook code recipes attached to datasets (serve-time join, no re-index).
+
+    Returns (by_dataset_id -> [records], by_notebook_id -> record,
+    generic_by_store -> [store-level how-to records]). Cached for process
+    lifetime: restart the server to pick up newly attached notebooks.
+    """
+    by_ds: dict = {}
+    by_id: dict = {}
+    generic: dict = {}
+    if NOTEBOOKS_SIDECAR.exists():
+        data = json.loads(NOTEBOOKS_SIDECAR.read_text())
+        by_ds = data.get("by_dataset", {})
+        generic = data.get("generic_by_store", {})
+        for recs in by_ds.values():
+            for r in recs:
+                by_id[r["notebook_id"]] = r
+        for recs in generic.values():
+            for r in recs:
+                by_id.setdefault(r["notebook_id"], r)
+    return by_ds, by_id, generic
+
+
+def _nb_refs(dataset_id: str | None, product_id: str | None = None,
+             kind: str | None = None) -> list[dict]:
+    """Compact notebook refs attached to a dataset/collection id (for list views)."""
+    by_ds, _, _ = _notebooks()
+    recs = by_ds.get(dataset_id or "") or by_ds.get(product_id or "") or []
+    out = []
+    for r in recs:
+        if kind and kind not in (r.get("recipe_kinds") or []):
+            continue
+        out.append({"notebook_id": r["notebook_id"], "title": r.get("title"),
+                    "recipe_kinds": r.get("recipe_kinds"),
+                    "n_code_lines": r.get("n_code_lines"),
+                    "source_repo": r.get("source_repo")})
+    return out
+
+
+def _query(collection: str, query: str, flt: models.Filter | None,
+           top_k: int, prefetch: int = 50, client: QdrantClient | None = None):
+    """Hybrid dense+sparse RRF; degrades to sparse-only if dense embed fails.
+
+    Only the embed call may trigger the fallback (SystemExit included: a
+    missing API key must not kill the server); Qdrant errors propagate to
+    the caller so they are reported as what they are.
+
+    Returns (points, retrieval_mode).
+    """
+    client = client or _qdrant()
+    sparse_vec = S.sparse_query(query)
+    dense_vec = None
+    try:
+        dense_vec = S.embed_query(query)
+    except (Exception, SystemExit) as e:
+        _log(f"dense embed unavailable ({repr(e)[:120]}); sparse-only fallback")
+    if dense_vec is not None:
+        res = client.query_points(
+            collection_name=collection,
+            prefetch=[
+                models.Prefetch(query=dense_vec, using="dense", limit=prefetch, filter=flt),
+                models.Prefetch(query=sparse_vec, using="sparse", limit=prefetch, filter=flt),
+            ],
+            query=models.FusionQuery(fusion=models.Fusion.RRF),
+            limit=top_k, with_payload=True,
+        )
+        return res.points, "hybrid(dense+bm25)"
+    res = client.query_points(
+        collection_name=collection, query=sparse_vec, using="sparse",
+        limit=top_k, with_payload=True, query_filter=flt,
+    )
+    return res.points, "bm25-only (dense embed unavailable)"
+
+
+def _maybe_rerank(query: str, points, top_k: int, rerank: bool):
+    if not rerank or not points:
+        return points, False
+    rr = S.rerank_google(query, points, top_k)
+    return (rr, True) if rr is not None else (points, False)
+
+
+def _err(msg: str, **extra) -> dict:
+    return {"ok": False, "error": msg, **extra}
+
+
+mcp = FastMCP("copernicus-rag")
+
+
+@mcp.tool()
+def search_datasets(query: str, store: str | None = None, top_k: int = 10,
+                    rerank: bool = False) -> dict:
+    """Semantic (RAG) search for Copernicus datasets by description, across all
+    four data stores: CMEMS (marine), CDS (climate/ERA5), ADS (atmosphere),
+    EWDS (emergency/flood/fire). One card per dataset (~1415 total).
+
+    Use this FIRST to discover which dataset to work with. Then, for CMEMS
+    results, call get_dataset_docs(product_id) to read its quality (EQC)
+    documentation before analyzing data.
+
+    Args:
+        query: natural-language description of the data you need
+               (e.g. "daily arctic sea ice concentration satellite").
+        store: optional filter — one of CMEMS, CDS, ADS, EWDS.
+        top_k: number of datasets to return (default 10).
+        rerank: also rerank with Google semantic-ranker (needs GCP ADC).
+    """
+    try:
+        if store:
+            store = store.upper()
+            if store not in STORES:
+                return _err(f"unknown store '{store}'", valid_stores=list(STORES))
+        top_k = max(1, min(int(top_k), 30))
+        flt = models.Filter(must=[models.FieldCondition(
+            key="store", match=models.MatchValue(value=store))]) if store else None
+        points, mode = _query(CARDS_COLLECTION, query, flt, max(top_k, 20))
+        points, reranked = _maybe_rerank(query, points, top_k, rerank)
+        by_pid, _ = _catalog()
+        results = []
+        for p in points[:top_k]:
+            pl = p.payload
+            pid = pl.get("product_id", "")
+            has_docs = bool(by_pid.get(pid, {}).get("has_docs"))
+            results.append({
+                "store": pl.get("store"),
+                "dataset_id": pl.get("dataset_id"),
+                "product_id": pid,
+                "title": pl.get("product_title"),
+                "description": (pl.get("text_raw") or "")[:MAX_TEXT],
+                "has_eqc_docs": has_docs,
+                "notebooks": _nb_refs(pl.get("dataset_id"), pid),
+                "score": getattr(p, "score", None),
+            })
+        return {"ok": True, "query": query, "store": store or "ALL",
+                "retrieval": mode, "reranked": reranked,
+                "n_results": len(results), "results": results,
+                "next_step": ("for CMEMS hits call get_dataset_docs(product_id) "
+                              "to read quality docs; where a hit has notebooks[], "
+                              "call get_dataset_code(dataset_id) for runnable code")}
+    except Exception as e:
+        _log(f"search_datasets failed: {repr(e)}")
+        return _err(f"search failed: {repr(e)[:200]}")
+
+
+def _deep_dataset_docs(dataset_id: str, question: str | None,
+                       top_k: int, rerank: bool) -> dict | None:
+    """Deep CDS/ADS/EWDS documentation (cds_docs) for a collection id.
+    Returns a result dict, or None if the deep index is unavailable / has no
+    match for this id (so the caller can fall through to 'unknown id')."""
+    client = _deep_qdrant()
+    if client is None:
+        return None
+    top_k = max(1, min(int(top_k), 20))
+    q = question or (f"{dataset_id} documentation: variables, methodology, accuracy, "
+                     "validation, how to use and interpret this dataset")
+    must = [models.FieldCondition(key="dataset_ids", match=models.MatchValue(value=dataset_id))]
+    points, mode = _query(DEEP_COLLECTION, q, models.Filter(must=must),
+                          max(top_k, 20), prefetch=40, client=client)
+    if not points:
+        return None
+    points, reranked = _maybe_rerank(q, points, top_k, rerank)
+    results = [{
+        "store": p.payload.get("store"),
+        "doc_title": p.payload.get("doc_title"),
+        "doc_url": p.payload.get("doc_url"),
+        "section": p.payload.get("section"),
+        "text": (p.payload.get("text_raw") or "")[:MAX_TEXT],
+        "score": getattr(p, "score", None),
+    } for p in points[:top_k]]
+    return {"ok": True, "dataset_id": dataset_id, "layer": "deep_docs (CDS/ADS/EWDS)",
+            "query": q, "retrieval": mode, "reranked": reranked,
+            "n_results": len(results), "results": results,
+            "notebooks": _nb_refs(dataset_id, dataset_id),
+            "next_step": ("get_eqc_quality_report(dataset_id) for quality assessment; "
+                          "get_dataset_code(dataset_id) for runnable code")}
+
+
+@mcp.tool()
+def get_dataset_docs(dataset_or_product_id: str, question: str | None = None,
+                     doc_type: str | None = None, top_k: int = 8,
+                     rerank: bool = False) -> dict:
+    """Level-2 EQC lookup: retrieve the quality/usage documentation chunks
+    (PUM = Product User Manual, QUID = Quality Information Document,
+    SQO = Scientific Quality Overview) for one CMEMS product or dataset.
+
+    Call this AFTER search_datasets, BEFORE analyzing data: it tells you the
+    variables, units, spatial/temporal coverage, accuracy, validation results
+    and known caveats — i.e. how to interpret the numbers you will pull.
+
+    Args:
+        dataset_or_product_id: CMEMS product_id or dataset_id
+            (e.g. "MEDSEA_ANALYSISFORECAST_PHY_006_013" or a dataset id).
+        question: optional focus (e.g. "salinity validation accuracy");
+            default surfaces the how-to-analyze essentials.
+        doc_type: optional filter — PUM, QUID or SQO.
+        top_k: number of doc chunks to return (default 8).
+        rerank: also rerank with Google semantic-ranker (needs GCP ADC).
+    """
+    try:
+        pid = resolve_product(dataset_or_product_id)
+        if not pid:
+            deep = _deep_dataset_docs(dataset_or_product_id, question, top_k, rerank)
+            if deep is not None:
+                return deep
+            return _err(f"unknown dataset/product id: {dataset_or_product_id}",
+                        hint="use an id returned by search_datasets")
+        by_pid, _ = _catalog()
+        prod = by_pid[pid]
+        if doc_type:
+            doc_type = doc_type.upper()
+            if doc_type not in DOC_TYPES:
+                return _err(f"unknown doc_type '{doc_type}'", valid=list(DOC_TYPES))
+        top_k = max(1, min(int(top_k), 20))
+        q = question or (f"{prod['product_title']} variables, spatial and temporal "
+                         "coverage, accuracy, validation, how to use and interpret "
+                         "this product")
+        must = [models.FieldCondition(key="product_id", match=models.MatchValue(value=pid))]
+        if doc_type:
+            must.append(models.FieldCondition(key="doc_type", match=models.MatchValue(value=doc_type)))
+        points, mode = _query(DOCS_COLLECTION, q, models.Filter(must=must), max(top_k, 20), prefetch=40)
+        points, reranked = _maybe_rerank(q, points, top_k, rerank)
+        results = [{
+            "doc_type": p.payload.get("doc_type"),
+            "doc_id": p.payload.get("doc_id"),
+            "section": p.payload.get("section_path"),
+            "text": (p.payload.get("text_raw") or "")[:MAX_TEXT],
+            "score": getattr(p, "score", None),
+        } for p in points[:top_k]]
+        return {"ok": True, "product_id": pid, "product_title": prod["product_title"],
+                "matched_by": "product_id" if dataset_or_product_id == pid else "dataset_id/fuzzy",
+                "doc_types_available": prod.get("doc_types", []),
+                "dataset_ids": prod.get("dataset_ids", []),
+                "query": q, "retrieval": mode, "reranked": reranked,
+                "n_results": len(results), "results": results,
+                "next_step": ("read_document(doc_id) pulls a full document; "
+                              "then subset data via the copernicus MCP server")}
+    except Exception as e:
+        _log(f"get_dataset_docs failed: {repr(e)}")
+        return _err(f"lookup failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def search_docs(query: str, doc_type: str | None = None, top_k: int = 8,
+                rerank: bool = False) -> dict:
+    """Global semantic search across ALL CMEMS quality documentation
+    (~29k chunks of PUM/QUID/SQO for 306 products), not limited to one product.
+
+    Use for cross-product questions like "which products are validated against
+    Argo floats" or "sea level trend uncertainty methodology".
+
+    Args:
+        query: natural-language question.
+        doc_type: optional filter — PUM, QUID or SQO.
+        top_k: number of chunks to return (default 8).
+        rerank: also rerank with Google semantic-ranker (needs GCP ADC).
+    """
+    try:
+        if doc_type:
+            doc_type = doc_type.upper()
+            if doc_type not in DOC_TYPES:
+                return _err(f"unknown doc_type '{doc_type}'", valid=list(DOC_TYPES))
+        top_k = max(1, min(int(top_k), 20))
+        flt = models.Filter(must=[models.FieldCondition(
+            key="doc_type", match=models.MatchValue(value=doc_type))]) if doc_type else None
+        points, mode = _query(DOCS_COLLECTION, query, flt, max(top_k, 20))
+        points, reranked = _maybe_rerank(query, points, top_k, rerank)
+        results = [{
+            "product_id": p.payload.get("product_id"),
+            "product_title": p.payload.get("product_title"),
+            "doc_type": p.payload.get("doc_type"),
+            "doc_id": p.payload.get("doc_id"),
+            "section": p.payload.get("section_path"),
+            "text": (p.payload.get("text_raw") or "")[:MAX_TEXT],
+            "score": getattr(p, "score", None),
+        } for p in points[:top_k]]
+        return {"ok": True, "query": query, "retrieval": mode, "reranked": reranked,
+                "n_results": len(results), "results": results}
+    except Exception as e:
+        _log(f"search_docs failed: {repr(e)}")
+        return _err(f"search failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def list_dataset_documents(dataset_or_product_id: str) -> dict:
+    """List the full EQC documents available for a CMEMS product/dataset:
+    doc_id, type (PUM/QUID/SQO) and size. Feed a doc_id to read_document
+    to pull the complete text.
+
+    Args:
+        dataset_or_product_id: CMEMS product_id or dataset_id.
+    """
+    try:
+        pid = resolve_product(dataset_or_product_id)
+        if not pid:
+            return _err(f"unknown dataset/product id: {dataset_or_product_id}")
+        by_pid, _ = _catalog()
+        prod = by_pid[pid]
+        docs = [{"doc_id": d["doc_id"], "doc_type": d["doc_type"],
+                 "size_bytes": d.get("md_bytes"), "available": d.get("has_md", False)}
+                for d in prod.get("docs", [])]
+        return {"ok": True, "product_id": pid, "product_title": prod["product_title"],
+                "dataset_ids": prod.get("dataset_ids", []),
+                "doi": prod.get("doi"), "regions": prod.get("regions", []),
+                "domains": prod.get("domains", []),
+                "n_documents": len(docs), "documents": docs}
+    except Exception as e:
+        _log(f"list_dataset_documents failed: {repr(e)}")
+        return _err(f"lookup failed: {repr(e)[:200]}")
+
+
+@lru_cache(maxsize=1)
+def _unified_meta() -> dict:
+    """Full harvested upstream metadata, all 4 stores (meta_harvest)."""
+    path = ROOT.parent / "meta_harvest" / "unified_metadata.json"
+    return json.loads(path.read_text()) if path.exists() else {}
+
+
+@mcp.tool()
+def dataset_metadata(dataset_or_collection_id: str) -> dict:
+    """FULL harvested metadata for one dataset (any store) — much richer than
+    the card returned by search_datasets: variables with units/standard_name/
+    bbox/depth/time ranges, services, processing level, production centre,
+    update frequency, documentation links, scientific references, licence.
+
+    Use before subsetting data: it tells you exact variable names, units and
+    coverage bounds. Accepts a CMEMS dataset_id, a CDS/ADS/EWDS collection id,
+    or a CMEMS product_id (then lists the product's datasets).
+
+    Args:
+        dataset_or_collection_id: e.g. "antarctic_omi_si_extent",
+            "reanalysis-era5-single-levels", or a CMEMS product_id.
+    """
+    try:
+        meta = _unified_meta()
+        if not meta:
+            return _err("unified_metadata.json not found — run the meta_harvest pipeline")
+        key = dataset_or_collection_id
+        entry = meta.get(key) or meta.get(key.lower())
+        if entry is None:
+            # maybe a CMEMS product_id → group its datasets
+            low = key.lower()
+            members = {k: v for k, v in meta.items()
+                       if (v.get("product_id") or "").lower() == low}
+            if members:
+                first = next(iter(members.values()))
+                return {"ok": True, "matched_by": "product_id",
+                        "product_id": first.get("product_id"),
+                        "title": first.get("title"), "doi": first.get("doi"),
+                        "store": first.get("store"),
+                        "n_datasets": len(members),
+                        "dataset_ids": sorted(members),
+                        "next_step": "call dataset_metadata with one dataset_id"}
+            close = [k for k in meta if low in k.lower()][:10]
+            return _err(f"unknown id: {key}",
+                        similar_ids=close,
+                        hint="use ids from search_datasets / list_dataset_documents")
+        out = dict(entry)
+        out["dataset_id"] = key if key in meta else key.lower()
+        for field, cap in (("variables", 120), ("references", 30),
+                           ("documentation_links", 40), ("keywords", 40)):
+            v = out.get(field)
+            if isinstance(v, list) and len(v) > cap:
+                out[field] = v[:cap]
+                out[f"{field}_truncated"] = f"{len(v) - cap} more omitted"
+        return {"ok": True, "matched_by": "dataset_id", **out}
+    except Exception as e:
+        _log(f"dataset_metadata failed: {repr(e)}")
+        return _err(f"lookup failed: {repr(e)[:200]}")
+
+
+@lru_cache(maxsize=1)
+def _doc_index() -> dict:
+    """doc_id -> absolute md path, from the catalog."""
+    by_pid, _ = _catalog()
+    idx = {}
+    for prod in by_pid.values():
+        for d in prod.get("docs", []):
+            if d.get("has_md") and d.get("md_path"):
+                idx[d["doc_id"]] = ROOT.parent / d["md_path"]
+    return idx
+
+
+@mcp.tool()
+def read_document(doc_id: str, offset: int = 0, max_chars: int = READ_DEFAULT) -> dict:
+    """Pull the full markdown text of one EQC document (PUM/QUID/SQO), paginated.
+    Get doc_id from list_dataset_documents or from get_dataset_docs results.
+    The first page includes an outline (headings + char offsets) so you can jump
+    straight to a section with the offset argument.
+
+    Args:
+        doc_id: e.g. "CMEMS-MED-QUID-006-013".
+        offset: character offset to start from (default 0).
+        max_chars: page size (default 20000, max 60000).
+    """
+    try:
+        path = _doc_index().get(doc_id)
+        if path is None:
+            return _err(f"unknown doc_id: {doc_id}",
+                        hint="use list_dataset_documents to get valid doc_ids")
+        if not path.exists():
+            return _err(f"document file missing on disk: {path.name}")
+        text = path.read_text(encoding="utf-8", errors="replace")
+        offset = max(0, int(offset))
+        max_chars = max(1000, min(int(max_chars), 60_000))
+        page = text[offset:offset + max_chars]
+        out = {"ok": True, "doc_id": doc_id, "total_chars": len(text),
+               "offset": offset, "returned_chars": len(page),
+               "next_offset": offset + len(page) if offset + len(page) < len(text) else None,
+               "text": page}
+        if offset == 0:
+            outline, pos = [], 0
+            for line in text.splitlines(keepends=True):
+                if line.startswith("#"):
+                    outline.append({"heading": line.strip()[:120], "offset": pos})
+                pos += len(line)
+            out["outline"] = outline[:60]
+        return out
+    except Exception as e:
+        _log(f"read_document failed: {repr(e)}")
+        return _err(f"read failed: {repr(e)[:200]}")
+
+
+@lru_cache(maxsize=1)
+def _registry() -> list[dict]:
+    # cached for process lifetime: restart server to pick up registry updates
+    if not REGISTRY.exists():
+        return []
+    return [json.loads(l) for l in REGISTRY.read_text().splitlines() if l.strip()]
+
+
+@lru_cache(maxsize=1)
+def _links_by_dataset() -> dict:
+    # dataset_id -> [paper records] materialized by pubs_rag/build_links_sidecar.py
+    # (registry direct + flagship citations, same logic as relink_full.py)
+    if not LINKS_SIDECAR.exists():
+        return {}
+    return json.loads(LINKS_SIDECAR.read_text(encoding="utf-8"))
+
+
+@lru_cache(maxsize=1)
+def _papers_by_id() -> dict:
+    """Orphan-corpus parsed papers: paper_id and doi -> record with md_path.
+
+    Cached for process lifetime (like _registry): restart to pick up new papers.
+    """
+    idx = {}
+    if PAPERS.exists():
+        for line in PAPERS.read_text().splitlines():
+            if not line.strip():
+                continue
+            p = json.loads(line)
+            idx[p["paper_id"]] = p
+            if p.get("doi"):
+                idx[p["doi"].lower()] = p
+    return idx
+
+
+@mcp.tool()
+def search_publications(query: str, domain: str | None = None,
+                        dataset_or_product_id: str | None = None,
+                        orphan_only: bool = False, top_k: int = 8,
+                        rerank: bool = False) -> dict:
+    """Level-3 METHODOLOGY search: semantic search over the scientific
+    publications RAG (parsed full-text paper chunks). Use it to learn HOW to
+    analyze data: methods, validation approaches, known analysis pitfalls.
+
+    Args:
+        query: natural-language question (e.g. "how to compute ocean heat
+            content trends from reanalysis").
+        domain: optional filter — one of ocean/marine, atmosphere, cryosphere,
+            land, climate-modeling, climate-general, emergency.
+        dataset_or_product_id: only papers LINKED to this Copernicus
+            product/collection (cited in its documentation).
+        orphan_only: only the general (non-dataset-linked) methodology corpus.
+        top_k: number of chunks to return (default 8).
+        rerank: also rerank with Google semantic-ranker (needs GCP ADC).
+    """
+    try:
+        client = _pubs_qdrant()
+        if client is None:
+            return _err("publications index not built yet", status=_pubs_status())
+        if domain and domain not in PUB_DOMAINS:
+            return _err(f"unknown domain '{domain}'", valid=list(PUB_DOMAINS))
+        top_k = max(1, min(int(top_k), 20))
+        must = []
+        if domain:
+            must.append(models.FieldCondition(key="domains", match=models.MatchValue(value=domain)))
+        if orphan_only:
+            must.append(models.FieldCondition(key="orphan", match=models.MatchValue(value=True)))
+        if dataset_or_product_id:
+            pid = resolve_product(dataset_or_product_id) or dataset_or_product_id
+            must.append(models.FieldCondition(key="linked_products", match=models.MatchValue(value=pid)))
+        flt = models.Filter(must=must) if must else None
+        points, mode = _query(PUBS_COLLECTION, query, flt, max(top_k, 20), client=client)
+        points, reranked = _maybe_rerank(query, points, top_k, rerank)
+        results = [{
+            "doi": p.payload.get("doi"),
+            "title": p.payload.get("title"),
+            "journal": p.payload.get("journal"),
+            "year": p.payload.get("year"),
+            "domains": p.payload.get("domains"),
+            "section": p.payload.get("section"),
+            "orphan": p.payload.get("orphan"),
+            "linked_products": (p.payload.get("linked_products") or [])[:8],
+            "text": (p.payload.get("text_raw") or "")[:MAX_TEXT],
+            "score": getattr(p, "score", None),
+        } for p in points[:top_k]]
+        return {"ok": True, "query": query, "retrieval": mode, "reranked": reranked,
+                "n_results": len(results), "results": results,
+                "next_step": "read_publication(doi) pulls a paper's full parsed text"}
+    except Exception as e:
+        _log(f"search_publications failed: {repr(e)}")
+        return _err(f"search failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def get_dataset_publications(dataset_or_product_id: str, top_k: int = 15) -> dict:
+    """List the scientific publications LINKED to one Copernicus dataset —
+    i.e. papers cited in its quality documentation (CMEMS PUM/QUID/SQO) or on
+    its CDS/ADS/EWDS references section. This is the dataset's literature:
+    validation papers, method papers, foundational references.
+
+    Args:
+        dataset_or_product_id: CMEMS product/dataset id or CDS/ADS/EWDS
+            collection id.
+        top_k: max publications to return (default 15), most-cited first.
+    """
+    try:
+        pid = resolve_product(dataset_or_product_id) or dataset_or_product_id
+        low = {pid.lower(), dataset_or_product_id.lower()}
+        parsed = _papers_by_id()
+
+        # primary: materialized links sidecar (registry direct + flagship citers)
+        seen: set[str] = set()
+        merged: list[dict] = []
+        by_ds = _links_by_dataset()
+        for ds, recs in by_ds.items():
+            if ds.lower() not in low:
+                continue
+            for r in recs:
+                doi = (r.get("doi") or "").lower()
+                if doi in seen:
+                    continue
+                seen.add(doi)
+                merged.append({
+                    "doi": r.get("doi"), "title": r.get("title"),
+                    "journal": r.get("journal"), "year": r.get("year"),
+                    "citations_count": r.get("cited_by_count"),
+                    "link_via": r.get("via"),
+                    "flagship_labels": r.get("flagship_labels") or None,
+                    "full_text_available": doi in parsed,
+                })
+
+        # secondary: registry papers not in the parsed corpus (metadata-only)
+        for r in _registry():
+            doi = (r.get("doi") or "").lower()
+            if doi in seen:
+                continue
+            if not any((p or "").lower() in low for p in r.get("linked_products", [])):
+                continue
+            seen.add(doi)
+            merged.append({
+                "doi": r["doi"], "title": r.get("title"),
+                "journal": r.get("journal"), "year": r.get("year"),
+                "authors": (r.get("authors") or [])[:6],
+                "n_mentions": r.get("n_mentions"),
+                "citations_count": r.get("citations_count"),
+                "pdf_status": r.get("pdf_status"),
+                "link_via": ["registry"],
+                "full_text_available": doi in parsed,
+            })
+
+        merged.sort(key=lambda r: (-int(bool(r.get("full_text_available"))),
+                                   -(r.get("citations_count") or 0)))
+        results = merged[:max(1, min(int(top_k), 50))]
+        return {"ok": True, "id": pid, "n_linked_publications": len(merged),
+                "results": results,
+                "next_step": ("read_publication(doi) for full text where "
+                              "full_text_available; otherwise metadata only for now")}
+    except Exception as e:
+        _log(f"get_dataset_publications failed: {repr(e)}")
+        return _err(f"lookup failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def read_publication(doi_or_paper_id: str, offset: int = 0,
+                     max_chars: int = READ_DEFAULT) -> dict:
+    """Pull the full parsed markdown text of one publication, paginated
+    (same contract as read_document: page 0 includes a heading outline).
+    Works for papers in the parsed corpus; for registry papers whose PDF is
+    not parsed yet it returns their metadata + abstract instead.
+
+    Args:
+        doi_or_paper_id: canonical DOI ("10.x/...") or underscored paper_id.
+        offset: character offset (default 0).
+        max_chars: page size (default 20000, max 60000).
+    """
+    try:
+        key = doi_or_paper_id.strip()
+        paper = _papers_by_id().get(key) or _papers_by_id().get(key.lower())
+        if paper and paper.get("md_path") and Path(paper["md_path"]).exists():
+            text = Path(paper["md_path"]).read_text(encoding="utf-8", errors="replace")
+            offset = max(0, int(offset))
+            max_chars = max(1000, min(int(max_chars), 60_000))
+            page = text[offset:offset + max_chars]
+            out = {"ok": True, "doi": paper.get("doi"), "title": paper.get("title"),
+                   "journal": paper.get("journal"), "year": paper.get("year"),
+                   "total_chars": len(text), "offset": offset,
+                   "returned_chars": len(page),
+                   "next_offset": offset + len(page) if offset + len(page) < len(text) else None,
+                   "text": page}
+            if offset == 0:
+                outline, pos = [], 0
+                for line in text.splitlines(keepends=True):
+                    if line.startswith("#"):
+                        outline.append({"heading": line.strip()[:120], "offset": pos})
+                    pos += len(line)
+                out["outline"] = outline[:60]
+            return out
+        # not parsed — fall back to registry metadata
+        low = key.lower()
+        rec = next((r for r in _registry() if r["doi"].lower() == low), None)
+        if rec:
+            return {"ok": True, "full_text": False,
+                    "reason": f"not parsed yet (pdf_status: {rec.get('pdf_status')})",
+                    "doi": rec["doi"], "title": rec.get("title"),
+                    "journal": rec.get("journal"), "year": rec.get("year"),
+                    "authors": rec.get("authors"), "abstract": rec.get("abstract"),
+                    "linked_products": (rec.get("linked_products") or [])[:15]}
+        return _err(f"unknown publication: {key}",
+                    hint="use a DOI from search_publications / get_dataset_publications")
+    except Exception as e:
+        _log(f"read_publication failed: {repr(e)}")
+        return _err(f"read failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def get_eqc_quality_report(query: str, dataset_id: str | None = None,
+                           aspect: str | None = None, top_k: int = 8,
+                           rerank: bool = False) -> dict:
+    """CDS/C3S EQC Quality Assessment reports — the curated fitness-for-purpose
+    assessments (consistency, completeness, etc.) for ~27 climate datasets that
+    carry the "Quality Assurance" badge in the CDS catalogue. Use this to judge
+    whether a CDS/ADS/EWDS dataset is suitable for a use case, to compare
+    alternative datasets on quality criteria, or to surface known limitations.
+
+    Complements get_dataset_docs (which serves CMEMS Marine PUM/QUID/SQO):
+    this tool serves the CDS-side quality knowledge.
+
+    Args:
+        query: natural-language question (e.g. "is the C3S atlas temperature
+            consistent across origins", "completeness of satellite soil moisture").
+        dataset_id: optional filter — a CDS collection id (e.g.
+            "multi-origin-c3s-atlas", "satellite-sea-surface-temperature").
+        aspect: optional filter — quality aspect prefix (e.g. "consistency",
+            "completeness").
+        top_k: number of report chunks to return (default 8).
+        rerank: also rerank with Google semantic-ranker (needs GCP ADC).
+    """
+    try:
+        client = _eqc_qdrant()
+        if client is None:
+            return _err("EQC-QA index not built yet",
+                        status="CDS quality-assessment reports are being embedded "
+                               "and indexed — retry shortly")
+        top_k = max(1, min(int(top_k), 20))
+        must = []
+        if dataset_id:
+            must.append(models.FieldCondition(key="dataset_id",
+                                              match=models.MatchValue(value=dataset_id)))
+        if aspect:
+            must.append(models.FieldCondition(key="aspect_base",
+                                              match=models.MatchValue(value=aspect.lower())))
+        flt = models.Filter(must=must) if must else None
+        points, mode = _query(EQC_QA_COLLECTION, query, flt, max(top_k, 20), client=client)
+        points, reranked = _maybe_rerank(query, points, top_k, rerank)
+        results = [{
+            "dataset_id": p.payload.get("dataset_id"),
+            "report_id": p.payload.get("report_id"),
+            "aspect": p.payload.get("aspect"),
+            "title": p.payload.get("title"),
+            "section": p.payload.get("section"),
+            "text": (p.payload.get("text_raw") or "")[:MAX_TEXT],
+            "code_notebooks": _nb_refs(p.payload.get("dataset_id")),
+            "score": getattr(p, "score", None),
+        } for p in points[:top_k]]
+        return {"ok": True, "query": query, "retrieval": mode, "reranked": reranked,
+                "n_results": len(results), "results": results,
+                "source": "c3s2-eqc-quality-assessment (CDS EQC QA reports)",
+                "next_step": ("where a result has code_notebooks[], call "
+                              "get_dataset_code(dataset_id, notebook_id=...) for the runnable code")}
+    except Exception as e:
+        _log(f"get_eqc_quality_report failed: {repr(e)}")
+        return _err(f"lookup failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def get_dataset_code(dataset_id: str, notebook_id: str | None = None,
+                     kind: str | None = None, offset: int = 0,
+                     max_chars: int = READ_DEFAULT) -> dict:
+    """Runnable CODE examples (Jupyter notebook cells) ATTACHED to a Copernicus
+    dataset: how to DOWNLOAD and ANALYZE it. Code is not embedded/searched on its
+    own — it rides along on the dataset, sourced from official example notebooks
+    (e.g. the C3S EQC quality-assessment notebooks). Reach it from a
+    search_datasets / get_eqc_quality_report hit whose notebooks[] is non-empty.
+
+    Two modes:
+      • dataset_id only  -> LIST the notebooks attached to that dataset (id, title,
+        recipe kinds download/analyze/plot, size, source repo + licence).
+      • + notebook_id    -> the FULL reconstructed notebook (verbatim ```python
+        cells + markdown + text outputs), paginated like read_document.
+
+    Args:
+        dataset_id: a CDS/ADS/EWDS collection id or CMEMS product/dataset id
+            (e.g. "satellite-sea-surface-temperature", "projections-cmip6").
+        notebook_id: pull one notebook's full code (from the list mode).
+        kind: optional filter for list mode — download, analyze or plot.
+        offset: character offset for the full-notebook mode (default 0).
+        max_chars: page size for the full-notebook mode (default 20000, max 60000).
+    """
+    try:
+        by_ds, by_id, generic = _notebooks()
+        if not by_ds and not generic:
+            return _err("notebook code layer not built yet",
+                        status="example notebooks are being extracted and attached")
+        if notebook_id:
+            rec = by_id.get(notebook_id)
+            if not rec:
+                return _err(f"unknown notebook_id: {notebook_id}",
+                            hint="call get_dataset_code(dataset_id) to list attached notebooks")
+            path = ROOT.parent / rec["md_path"]
+            if not path.exists():
+                return _err(f"notebook file missing on disk: {path.name}")
+            text = path.read_text(encoding="utf-8", errors="replace")
+            offset = max(0, int(offset))
+            max_chars = max(1000, min(int(max_chars), 60_000))
+            page = text[offset:offset + max_chars]
+            return {"ok": True, "notebook_id": notebook_id, "title": rec.get("title"),
+                    "dataset_id": rec.get("matched_dataset_id"), "store": rec.get("store"),
+                    "recipe_kinds": rec.get("recipe_kinds"),
+                    "source_repo": rec.get("source_repo"), "license": rec.get("license"),
+                    "src_path": rec.get("src_path"),
+                    "total_chars": len(text), "offset": offset,
+                    "returned_chars": len(page),
+                    "next_offset": offset + len(page) if offset + len(page) < len(text) else None,
+                    "text": page}
+        # list mode — dataset-specific notebooks + a store-level generic how-to fallback
+        recs = by_ds.get(dataset_id) or by_ds.get(dataset_id.lower())
+        if not recs:
+            pid = resolve_product(dataset_id)
+            if pid:
+                recs = by_ds.get(pid)
+        recs = recs or []
+        store = next((r.get("store") for r in recs if r.get("store")), None)
+        if not store:
+            store = "CMEMS" if resolve_product(dataset_id) else None
+
+        def _brief(r, scope):
+            return {"notebook_id": r["notebook_id"], "title": r.get("title"),
+                    "scope": scope, "recipe_kinds": r.get("recipe_kinds"),
+                    "n_code_cells": r.get("n_code_cells"),
+                    "n_code_lines": r.get("n_code_lines"), "aspect": r.get("aspect"),
+                    "source_repo": r.get("source_repo"), "license": r.get("license")}
+
+        notebooks = [_brief(r, "dataset") for r in recs
+                     if not kind or kind in (r.get("recipe_kinds") or [])]
+        generic_how_to = [_brief(r, "generic") for r in (generic.get(store) or [])
+                          if not kind or kind in (r.get("recipe_kinds") or [])]
+        if not notebooks and not generic_how_to:
+            return _err(f"no notebooks attached to '{dataset_id}'",
+                        hint="notebooks cover CDS/ADS/EWDS + CMEMS example datasets",
+                        example_ids=sorted(by_ds)[:12])
+        return {"ok": True, "dataset_id": dataset_id, "store": store,
+                "n_notebooks": len(notebooks), "notebooks": notebooks,
+                "generic_how_to": generic_how_to,
+                "next_step": ("call get_dataset_code(dataset_id, notebook_id=...) "
+                              "for one notebook's full runnable code")}
+    except Exception as e:
+        _log(f"get_dataset_code failed: {repr(e)}")
+        return _err(f"lookup failed: {repr(e)[:200]}")
+
+
+@mcp.tool()
+def search_deep_docs(query: str, store: str | None = None, top_k: int = 8,
+                     rerank: bool = False) -> dict:
+    """Global semantic search across the DEEP documentation of the non-marine
+    stores — CDS (climate/ERA5), ADS (atmosphere/CAMS), EWDS (emergency/flood/
+    fire): Confluence user guides, ATBDs, product specs and PDFs (~23k chunks
+    over 165 datasets). The non-marine counterpart to search_docs (which covers
+    CMEMS PUM/QUID/SQO). Use for cross-dataset climate/atmosphere/emergency
+    questions ("ERA5-Land soil moisture accuracy", "CAMS aerosol assimilation").
+
+    Args:
+        query: natural-language question.
+        store: optional filter — CDS, ADS or EWDS.
+        top_k: number of chunks to return (default 8).
+        rerank: also rerank with Google semantic-ranker (needs GCP ADC).
+    """
+    try:
+        client = _deep_qdrant()
+        if client is None:
+            return _err("deep-docs index not built yet",
+                        status="CDS/ADS/EWDS documentation is being fetched, chunked "
+                               "and embedded — retry shortly")
+        if store:
+            store = store.upper()
+            if store not in ("CDS", "ADS", "EWDS"):
+                return _err(f"unknown store '{store}'", valid=["CDS", "ADS", "EWDS"])
+        top_k = max(1, min(int(top_k), 20))
+        flt = models.Filter(must=[models.FieldCondition(
+            key="store", match=models.MatchValue(value=store))]) if store else None
+        points, mode = _query(DEEP_COLLECTION, query, flt, max(top_k, 20), client=client)
+        points, reranked = _maybe_rerank(query, points, top_k, rerank)
+        results = [{
+            "store": p.payload.get("store"),
+            "dataset_ids": (p.payload.get("dataset_ids") or [])[:6],
+            "doc_title": p.payload.get("doc_title"),
+            "doc_url": p.payload.get("doc_url"),
+            "section": p.payload.get("section"),
+            "text": (p.payload.get("text_raw") or "")[:MAX_TEXT],
+            "score": getattr(p, "score", None),
+        } for p in points[:top_k]]
+        return {"ok": True, "query": query, "store": store or "CDS/ADS/EWDS",
+                "retrieval": mode, "reranked": reranked,
+                "n_results": len(results), "results": results}
+    except Exception as e:
+        _log(f"search_deep_docs failed: {repr(e)}")
+        return _err(f"search failed: {repr(e)[:200]}")
+
+
+if __name__ == "__main__":
+    _log("starting copernicus-rag MCP server (stdio)")
+    mcp.run()

scripts/marine_rag/run_overnight.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# run_overnight.sh — autonomous marine-docs RAG finisher.
+# Retries the API-dependent steps every 10 min until the Gemini key's IP
+# restriction is lifted, then embeds → indexes → verifies, and stops.
+# Phases A/B (catalog, tree, chunking) are already done.
+set -uo pipefail
+
+cd /Users/dmpantiu/copernicus_mcp/marine_rag
+PY=/Users/dmpantiu/cmip6/cmip6_gpt/.venv/bin/python
+LOG=out/overnight.log
+INTERVAL=600          # 10 minutes
+MAX_RETRIES=66        # ~11 hours
+TOTAL_CHUNKS=$(wc -l < out/chunks.jsonl | tr -d ' ')
+
+ts() { date '+%Y-%m-%d %H:%M:%S'; }
+log() { echo "[$(ts)] $*" | tee -a "$LOG"; }
+
+log "=== overnight runner started. total chunks=$TOTAL_CHUNKS ==="
+
+embedded_count() { [ -f out/chunks_embedded.jsonl ] && wc -l < out/chunks_embedded.jsonl | tr -d ' ' || echo 0; }
+
+attempt=0
+while [ "$attempt" -lt "$MAX_RETRIES" ]; do
+  attempt=$((attempt+1))
+  have=$(embedded_count)
+  log "attempt $attempt/$MAX_RETRIES — embedded $have/$TOTAL_CHUNKS"
+
+  if [ "$have" -ge "$TOTAL_CHUNKS" ]; then
+    log "all chunks embedded — proceeding to index."
+    break
+  fi
+
+  # Resumable embed; stream output to log (don't buffer — run is ~60 min at 5 RPM).
+  $PY embed.py --mode realtime >> "$LOG" 2>&1
+  if tail -5 "$LOG" | grep -q "IP address restriction"; then
+    log "BLOCKED: Gemini key IP restriction active. Whitelist IP, will retry in ${INTERVAL}s."
+    sleep "$INTERVAL"
+    continue
+  fi
+
+  have=$(embedded_count)
+  if [ "$have" -ge "$TOTAL_CHUNKS" ]; then
+    log "embedding complete: $have/$TOTAL_CHUNKS"
+    break
+  fi
+  log "partial/failed embed ($have/$TOTAL_CHUNKS) — retry in ${INTERVAL}s"
+  sleep "$INTERVAL"
+done
+
+have=$(embedded_count)
+if [ "$have" -lt "$TOTAL_CHUNKS" ]; then
+  log "EXIT: did not finish embedding ($have/$TOTAL_CHUNKS) after $attempt attempts."
+  exit 2
+fi
+
+log "indexing into Qdrant (local mode)…"
+$PY load_qdrant.py --recreate 2>&1 | tee -a "$LOG"
+
+log "verification search…"
+$PY search.py "how is sea surface salinity validated" --top-k 3 2>&1 | tee -a "$LOG"
+
+log "=== overnight runner DONE: embedded=$have, indexed, verified. ==="

scripts/marine_rag/search.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+search.py — Hybrid retrieval over marine docs + Google reranker.
+
+Pipeline:
+  1. embed query with gemini-embedding-2-preview (RETRIEVAL_QUERY, 768-dim)
+  2. Qdrant hybrid: dense (Cosine) + sparse (BM25), RRF fusion
+  3. rerank top candidates with Google Vertex AI Rank API
+     (semantic-ranker-default@latest) — NOT an LLM. Needs GCP ADC + project.
+     Falls back to fusion order if ADC/project unavailable.
+
+Usage:
+  python search.py "how is Mediterranean salinity validated" --top-k 5 --rerank
+  python search.py "Arctic sea ice concentration accuracy" --product OMI...
+"""
+import argparse
+import os
+import sys
+import threading
+from pathlib import Path
+
+import net_ipv4  # noqa: F401  — force IPv4 egress (VPN), must precede genai client
+
+from qdrant_client import QdrantClient, models
+from fastembed import SparseTextEmbedding
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "out"
+COLLECTION = "marine_docs"
+DENSE_DIM = 768
+LOCAL_DB = OUT / "qdrant_db"
+RANK_MODEL = "semantic-ranker-default@latest"
+
+_bm25 = None
+_bm25_lock = threading.Lock()
+
+
+def resolve_key() -> str:
+    for var in ("GOOGLE_API_KEY", "GEMINI_API_KEY"):
+        if os.environ.get(var):
+            return os.environ[var]
+    for env in (Path("/Users/dmpantiu/copernicus_mcp/.env"),
+                Path("/Users/dmpantiu/cmip6/cmip6_gpt/.env")):
+        if env.exists():
+            for line in env.read_text().splitlines():
+                line = line.strip()
+                if "api_key" in line.lower() and "=" in line and not line.startswith("#"):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    raise SystemExit("No Gemini API key.")
+
+
+def embed_query(query: str) -> list[float]:
+    from google import genai
+    from google.genai import types
+    client = genai.Client(api_key=resolve_key())
+    r = client.models.embed_content(
+        model="gemini-embedding-2-preview", contents=query,
+        config=types.EmbedContentConfig(task_type="RETRIEVAL_QUERY", output_dimensionality=DENSE_DIM))
+    import numpy as np
+    v = np.array(list(r.embeddings[0].values), dtype=np.float32)
+    n = np.linalg.norm(v)
+    return (v / n).tolist() if n > 0 else v.tolist()
+
+
+def sparse_query(query: str) -> models.SparseVector:
+    global _bm25
+    with _bm25_lock:  # tools may run on multiple threads (FastMCP)
+        if _bm25 is None:
+            _bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+    sp = list(_bm25.query_embed(query))[0]
+    return models.SparseVector(indices=sp.indices.tolist(), values=sp.values.tolist())
+
+
+def get_client(url=None) -> QdrantClient:
+    return QdrantClient(url=url, check_compatibility=False) if url else QdrantClient(path=str(LOCAL_DB))
+
+
+def hybrid(client, query, top_k=5, prefetch=50, product_id=None, doc_type=None):
+    flt = None
+    must = []
+    if product_id:
+        must.append(models.FieldCondition(key="product_id", match=models.MatchValue(value=product_id)))
+    if doc_type:
+        must.append(models.FieldCondition(key="doc_type", match=models.MatchValue(value=doc_type)))
+    if must:
+        flt = models.Filter(must=must)
+    res = client.query_points(
+        collection_name=COLLECTION,
+        prefetch=[
+            models.Prefetch(query=embed_query(query), using="dense", limit=prefetch, filter=flt),
+            models.Prefetch(query=sparse_query(query), using="sparse", limit=prefetch, filter=flt),
+        ],
+        query=models.FusionQuery(fusion=models.Fusion.RRF),
+        limit=prefetch, with_payload=True,
+    )
+    return res.points[:max(top_k, prefetch)]
+
+
+def rerank_google(query, points, top_k):
+    """Vertex AI Rank API. Needs ADC + GCP project (GCP_PROJECT env)."""
+    try:
+        from google.cloud import discoveryengine_v1 as de
+        project = os.environ.get("GCP_PROJECT")
+        if not project:
+            return None
+        client = de.RankServiceClient()
+        cfg = client.ranking_config_path(project=project, location="global",
+                                          ranking_config="default_ranking_config")
+        records = [de.RankingRecord(id=str(i), content=p.payload.get("text_raw", ""))
+                   for i, p in enumerate(points)]
+        resp = client.rank(request=de.RankRequest(
+            ranking_config=cfg, model=RANK_MODEL, query=query,
+            records=records, top_n=top_k))
+        order = [int(r.id) for r in resp.records]
+        return [points[i] for i in order][:top_k]
+    except Exception as e:
+        # stderr only: stdout is the MCP JSON-RPC channel when used by rag_server
+        print(f"[rerank] unavailable ({repr(e)[:80]}); using fusion order", file=sys.stderr)
+        return None
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("query")
+    ap.add_argument("--top-k", type=int, default=5)
+    ap.add_argument("--rerank", action="store_true")
+    ap.add_argument("--product", type=str, default=None)
+    ap.add_argument("--doc-type", type=str, default=None)
+    ap.add_argument("--url", type=str, default=None)
+    a = ap.parse_args()
+    client = get_client(a.url)
+    points = hybrid(client, a.query, a.top_k, 50, a.product, a.doc_type)
+    if a.rerank:
+        rr = rerank_google(a.query, points, a.top_k)
+        if rr is not None:
+            points = rr
+    for i, p in enumerate(points[:a.top_k], 1):
+        pl = p.payload
+        print(f"\n#{i}  {pl['product_id']} · {pl['doc_type']} · {pl.get('section_path','')[:60]}")
+        print(f"    {pl.get('text_raw','')[:300].strip()}")
+
+
+if __name__ == "__main__":
+    main()

scripts/marine_rag/verify_copernicus_docs.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+verify_copernicus_docs.py — sanity-check the unified copernicus_docs index
+WITHOUT hitting the Gemini quota:
+
+  1. point counts per store
+  2. BM25 (sparse) keyword queries per domain — local FastEmbed, no API
+  3. dense neighbour check — reuse a stored card vector as the query vector
+
+Prints top hits so we can eyeball that the right datasets surface per store.
+"""
+import json
+from pathlib import Path
+
+from qdrant_client import QdrantClient, models
+from fastembed import SparseTextEmbedding
+
+OUT = Path(__file__).resolve().parent / "out"
+COLLECTION = "copernicus_docs"
+client = QdrantClient(path=str(OUT / "qdrant_db"))
+_bm25 = SparseTextEmbedding(model_name="Qdrant/bm25")
+
+
+def sparse(text):
+    r = list(_bm25.embed([text]))[0]
+    return models.SparseVector(indices=r.indices.tolist(), values=r.values.tolist())
+
+
+def kw_search(q, k=5, store=None):
+    flt = models.Filter(must=[models.FieldCondition(key="store", match=models.MatchValue(value=store))]) if store else None
+    res = client.query_points(collection_name=COLLECTION, query=sparse(q),
+                              using="sparse", limit=k, with_payload=True, query_filter=flt).points
+    return res
+
+
+def main():
+    info = client.get_collection(COLLECTION)
+    print(f"=== {COLLECTION}: {info.points_count} points ===\n")
+
+    # per-store counts
+    print("per-store counts:")
+    for s in ("CMEMS", "CDS", "ADS", "EWDS"):
+        cnt = client.count(collection_name=COLLECTION,
+                           count_filter=models.Filter(must=[models.FieldCondition(
+                               key="store", match=models.MatchValue(value=s))])).count
+        print(f"  {s:6s} {cnt}")
+
+    # BM25 keyword probes across domains
+    probes = [
+        ("sea surface temperature satellite", None),
+        ("greenhouse gas carbon dioxide forecast", "ADS"),
+        ("river discharge flood forecast europe", "EWDS"),
+        ("ERA5 reanalysis climate", "CDS"),
+        ("ocean salinity mediterranean", "CMEMS"),
+        ("wildfire fire danger", None),
+    ]
+    print("\n=== BM25 keyword probes ===")
+    for q, store in probes:
+        print(f"\nQ: {q!r}" + (f"  [store={store}]" if store else ""))
+        for p in kw_search(q, k=4, store=store):
+            pl = p.payload
+            print(f"  {p.score:5.2f} [{pl.get('store'):5s}] {pl.get('dataset_id','')[:45]:45s} {pl.get('product_title','')[:40]}")
+
+    # dense neighbour check — take one CDS card's stored vector, find nearest
+    print("\n=== dense neighbour check (stored vector as query) ===")
+    sample = client.scroll(collection_name=COLLECTION, limit=1, with_vectors=True,
+                           scroll_filter=models.Filter(must=[models.FieldCondition(
+                               key="store", match=models.MatchValue(value="CDS"))]))[0][0]
+    print(f"seed: [{sample.payload['store']}] {sample.payload.get('dataset_id')}")
+    nn = client.query_points(collection_name=COLLECTION, query=sample.vector["dense"],
+                             using="dense", limit=5, with_payload=True).points
+    for p in nn:
+        print(f"  {p.score:5.3f} [{p.payload.get('store'):5s}] {p.payload.get('dataset_id','')[:45]}")
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/01_dump_cmems.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+"""Dump the full CMEMS catalogue via copernicusmarine.describe() to raw JSON."""
+import json
+import os
+import sys
+import time
+
+OUT = "/Users/dmpantiu/copernicus_mcp/meta_harvest/raw/cmems_describe_full.json"
+
+def main():
+    if os.path.exists(OUT) and os.path.getsize(OUT) > 10_000_000:
+        print(f"already exists ({os.path.getsize(OUT)} bytes), skipping")
+        return
+    import copernicusmarine
+    t0 = time.time()
+    cat = copernicusmarine.describe(
+        show_all_versions=True,
+        disable_progress_bar=True,
+    )
+    print(f"describe() took {time.time()-t0:.1f}s")
+    # pydantic v2 model
+    data = cat.model_dump(mode="json", exclude_none=False)
+    tmp = OUT + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(data, f)
+    os.replace(tmp, OUT)
+    print(f"wrote {OUT}: {os.path.getsize(OUT)} bytes, {len(data.get('products', []))} products")
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/meta_harvest/02_harvest_stac.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+"""Harvest full STAC collection records from CDS / ADS / EWDS catalogue APIs.
+
+Produces raw/{store}_collections_full.json = list of full per-collection records
+(fetched individually so nothing is truncated by the list endpoint).
+Polite: <=2 req/s per host, retries with backoff, resumable via cache dir.
+"""
+import json
+import os
+import sys
+import time
+
+import httpx
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+CACHE = os.path.join(BASE, "raw", "stac_cache")
+STORES = {
+    "cds": "https://cds.climate.copernicus.eu/api/catalogue/v1",
+    "ads": "https://ads.atmosphere.copernicus.eu/api/catalogue/v1",
+    "ewds": "https://ewds.climate.copernicus.eu/api/catalogue/v1",
+}
+HEADERS = {"User-Agent": "meta-harvest/1.0 (research; contact: local)"}
+MIN_INTERVAL = 0.5  # 2 req/s
+
+_last_req = {}
+
+def get_json(client, url, host):
+    for attempt in range(6):
+        wait = MIN_INTERVAL - (time.time() - _last_req.get(host, 0))
+        if wait > 0:
+            time.sleep(wait)
+        try:
+            _last_req[host] = time.time()
+            r = client.get(url, headers=HEADERS, timeout=60)
+            if r.status_code == 200:
+                return r.json()
+            if r.status_code in (429, 500, 502, 503, 504):
+                time.sleep(2 ** attempt)
+                continue
+            print(f"  HTTP {r.status_code} for {url}", flush=True)
+            return None
+        except (httpx.HTTPError, json.JSONDecodeError) as e:
+            print(f"  error {e!r} for {url}, retry {attempt}", flush=True)
+            time.sleep(2 ** attempt)
+    return None
+
+def main():
+    os.makedirs(CACHE, exist_ok=True)
+    with httpx.Client(follow_redirects=True) as client:
+        for store, base in STORES.items():
+            out = os.path.join(BASE, "raw", f"{store}_collections_full.json")
+            if os.path.exists(out) and os.path.getsize(out) > 1000:
+                print(f"{store}: output exists, skipping")
+                continue
+            host = base.split("/")[2]
+            listing = get_json(client, f"{base}/collections?limit=1000", host)
+            if listing is None:
+                print(f"{store}: FAILED to list collections")
+                continue
+            ids = [c["id"] for c in listing.get("collections", [])]
+            print(f"{store}: {len(ids)} collections listed", flush=True)
+            full = []
+            failed = []
+            for i, cid in enumerate(ids):
+                cpath = os.path.join(CACHE, f"{store}__{cid}.json")
+                if os.path.exists(cpath) and os.path.getsize(cpath) > 100:
+                    with open(cpath) as f:
+                        full.append(json.load(f))
+                    continue
+                rec = get_json(client, f"{base}/collections/{cid}", host)
+                if rec is None:
+                    failed.append(cid)
+                    # fall back to listing record
+                    rec = next(c for c in listing["collections"] if c["id"] == cid)
+                else:
+                    with open(cpath, "w") as f:
+                        json.dump(rec, f)
+                full.append(rec)
+                if (i + 1) % 25 == 0:
+                    print(f"  {store}: {i+1}/{len(ids)}", flush=True)
+            tmp = out + ".tmp"
+            with open(tmp, "w") as f:
+                json.dump(full, f)
+            os.replace(tmp, out)
+            print(f"{store}: wrote {out} ({os.path.getsize(out)} bytes), "
+                  f"{len(full)} records, {len(failed)} fetch-failures: {failed}", flush=True)
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/meta_harvest/03_enrich_cmems.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+"""Build cmems_products_enriched.json and cmems_datasets_enriched.json
+from raw/cmems_describe_full.json."""
+import json
+import os
+from datetime import datetime, timezone
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+RAW = os.path.join(BASE, "raw", "cmems_describe_full.json")
+
+
+def coord_bounds(coord):
+    """Return (min, max) using min/max fields, falling back to values[]."""
+    mn, mx = coord.get("minimum_value"), coord.get("maximum_value")
+    vals = coord.get("values")
+    if mn is None and vals:
+        try:
+            mn = min(vals)
+        except TypeError:
+            mn = vals[0]
+    if mx is None and vals:
+        try:
+            mx = max(vals)
+        except TypeError:
+            mx = vals[-1]
+    return mn, mx
+
+
+def to_iso(val, unit):
+    if val is None:
+        return None
+    u = (unit or "").lower()
+    try:
+        if u.startswith("milliseconds since 1970"):
+            return datetime.fromtimestamp(val / 1000.0, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        if u.startswith("seconds since 1970"):
+            return datetime.fromtimestamp(float(val), tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    except (OSError, OverflowError, ValueError, TypeError):
+        pass
+    return val
+
+
+def extract_variable(var):
+    out = {
+        "short_name": var.get("short_name"),
+        "standard_name": var.get("standard_name"),
+        "units": var.get("units"),
+        "bbox": var.get("bbox"),
+    }
+    depth_range = None
+    time_range = None
+    for co in var.get("coordinates") or []:
+        cid = (co.get("coordinate_id") or "").lower()
+        mn, mx = coord_bounds(co)
+        if cid == "time":
+            unit = co.get("coordinate_unit")
+            time_range = [to_iso(mn, unit), to_iso(mx, unit)]
+        elif cid in ("depth", "elevation"):
+            depth_range = {
+                "min": mn,
+                "max": mx,
+                "units": co.get("coordinate_unit"),
+                "coordinate_id": cid,
+            }
+    out["depth_range"] = depth_range
+    out["time_range"] = time_range
+    return out
+
+
+def merge_variable(existing, new):
+    """Widen bounds so the merged variable covers all services/parts."""
+    for k in ("standard_name", "units"):
+        if not existing.get(k):
+            existing[k] = new.get(k)
+    b1, b2 = existing.get("bbox"), new.get("bbox")
+    if b1 and b2 and len(b1) == 4 and len(b2) == 4:
+        existing["bbox"] = [min(b1[0], b2[0]), min(b1[1], b2[1]),
+                            max(b1[2], b2[2]), max(b1[3], b2[3])]
+    elif not b1:
+        existing["bbox"] = b2
+    d1, d2 = existing.get("depth_range"), new.get("depth_range")
+    if d1 and d2:
+        try:
+            d1["min"] = min(d1["min"], d2["min"]) if None not in (d1["min"], d2["min"]) else d1["min"] or d2["min"]
+            d1["max"] = max(d1["max"], d2["max"]) if None not in (d1["max"], d2["max"]) else d1["max"] or d2["max"]
+        except TypeError:
+            pass
+    elif not d1:
+        existing["depth_range"] = d2
+    t1, t2 = existing.get("time_range"), new.get("time_range")
+    if t1 and t2:
+        try:
+            if t2[0] is not None and (t1[0] is None or str(t2[0]) < str(t1[0])):
+                t1[0] = t2[0]
+            if t2[1] is not None and (t1[1] is None or str(t2[1]) > str(t1[1])):
+                t1[1] = t2[1]
+        except TypeError:
+            pass
+    elif not t1:
+        existing["time_range"] = t2
+
+
+def main():
+    with open(RAW) as f:
+        cat = json.load(f)
+
+    products_out = {}
+    datasets_out = {}
+
+    for p in cat["products"]:
+        pid = p["product_id"]
+        ds_summaries = []
+        for ds in p["datasets"]:
+            did = ds["dataset_id"]
+            versions = sorted(ds.get("versions") or [],
+                              key=lambda v: v.get("label") or "", reverse=True)
+            versions_out = []
+            all_vars = {}   # short_name -> merged var (from latest version only)
+            services_out = []
+            for vi, v in enumerate(versions):
+                parts_out = []
+                for part in v.get("parts") or []:
+                    svc_list = []
+                    for svc in part.get("services") or []:
+                        uri = svc.get("uri") or ""
+                        svc_list.append({
+                            "name": svc.get("service_name"),
+                            "short_name": svc.get("service_short_name"),
+                            "format": svc.get("service_format"),
+                            "uri": uri,
+                            "uri_scheme": uri.split("://", 1)[0] if "://" in uri else None,
+                            "arco_sparse_type": svc.get("arco_sparse_type"),
+                        })
+                        if vi == 0:  # latest version: harvest variables
+                            for var in svc.get("variables") or []:
+                                ev = extract_variable(var)
+                                sn = ev["short_name"]
+                                if sn in all_vars:
+                                    merge_variable(all_vars[sn], ev)
+                                else:
+                                    all_vars[sn] = ev
+                    parts_out.append({
+                        "name": part.get("name"),
+                        "released_date": part.get("released_date"),
+                        "retired_date": part.get("retired_date"),
+                        "url_metadata": part.get("url_metadata"),
+                        "services": svc_list,
+                    })
+                    if vi == 0:
+                        services_out.extend(svc_list)
+                versions_out.append({"label": v.get("label"), "parts": parts_out})
+
+            datasets_out[did] = {
+                "dataset_id": did,
+                "dataset_name": ds.get("dataset_name"),
+                "product_id": pid,
+                "digital_object_identifier": ds.get("digital_object_identifier"),
+                "latest_version": versions[0].get("label") if versions else None,
+                "versions": versions_out,
+                "services": services_out,   # latest-version services flattened
+                "variables": list(all_vars.values()),
+            }
+            ds_summaries.append({
+                "dataset_id": did,
+                "dataset_name": ds.get("dataset_name"),
+                "latest_version": versions[0].get("label") if versions else None,
+                "n_variables": len(all_vars),
+                "variables": sorted(all_vars.keys()),
+            })
+
+        products_out[pid] = {
+            "product_id": pid,
+            "title": p.get("title"),
+            "digital_object_identifier": p.get("digital_object_identifier"),
+            "sources": p.get("sources"),
+            "processing_level": p.get("processing_level"),
+            "production_center": p.get("production_center"),
+            "keywords": p.get("keywords"),
+            "thumbnail_url": p.get("thumbnail_url"),
+            "description": p.get("description"),
+            "datasets": ds_summaries,
+        }
+
+    with open(os.path.join(BASE, "cmems_products_enriched.json"), "w") as f:
+        json.dump(products_out, f)
+    with open(os.path.join(BASE, "cmems_datasets_enriched.json"), "w") as f:
+        json.dump(datasets_out, f)
+
+    # quick coverage stats
+    nvar = sum(len(d["variables"]) for d in datasets_out.values())
+    nunits = sum(1 for d in datasets_out.values() for v in d["variables"] if v.get("units"))
+    nstd = sum(1 for d in datasets_out.values() for v in d["variables"] if v.get("standard_name"))
+    ntime = sum(1 for d in datasets_out.values() for v in d["variables"] if v.get("time_range"))
+    print(f"products: {len(products_out)}, datasets: {len(datasets_out)}, variables: {nvar}")
+    print(f"  units: {nunits} ({nunits/nvar:.1%}), standard_name: {nstd} ({nstd/nvar:.1%}), time_range: {ntime} ({ntime/nvar:.1%})")
+    print(f"  products with doi: {sum(1 for p in products_out.values() if p['digital_object_identifier'])}")
+    print(f"  products with processing_level: {sum(1 for p in products_out.values() if p['processing_level'])}")
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/04_harvest_pages.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+"""Fetch the per-dataset 'layout' JSON (drives the CDS/ADS/EWDS web pages) for
+every collection. This holds the Documentation section and References/Citation
+aside that are NOT in the STAC record proper.
+
+Saves raw/pages/{store}/{id}.json ; builds cds_references.json (all 3 stores).
+Polite: <=2 req/s per host, retries with backoff, resumable.
+"""
+import json
+import os
+import re
+import time
+
+import httpx
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+STORES = ["cds", "ads", "ewds"]
+HEADERS = {"User-Agent": "meta-harvest/1.0 (research; contact: local)"}
+MIN_INTERVAL = 0.5
+_last_req = {}
+
+DOI_RE = re.compile(r"10\.\d{4,9}/[-._;()/:A-Za-z0-9]+")
+MDLINK_RE = re.compile(r"\[([^\]]+)\]\((https?://[^)\s]+)\)")
+
+
+def get(client, url):
+    host = url.split("/")[2]
+    for attempt in range(6):
+        wait = MIN_INTERVAL - (time.time() - _last_req.get(host, 0))
+        if wait > 0:
+            time.sleep(wait)
+        try:
+            _last_req[host] = time.time()
+            r = client.get(url, headers=HEADERS, timeout=60)
+            if r.status_code == 200:
+                return r
+            if r.status_code in (429, 500, 502, 503, 504):
+                time.sleep(2 ** attempt)
+                continue
+            print(f"  HTTP {r.status_code} {url}", flush=True)
+            return None
+        except httpx.HTTPError as e:
+            print(f"  err {e!r} {url} retry {attempt}", flush=True)
+            time.sleep(2 ** attempt)
+    return None
+
+
+def walk_blocks(blocks):
+    for b in blocks or []:
+        yield b
+        yield from walk_blocks(b.get("blocks"))
+
+
+def extract_from_layout(layout):
+    """Return (documentation_links, references) from a layout JSON."""
+    doc_links = []
+    references = []
+    body = layout.get("body") or {}
+    sections = list((body.get("main") or {}).get("sections") or [])
+    aside = body.get("aside") or {}
+    aside_secs = [aside] if aside else []
+
+    def clean_doi(s):
+        return s.rstrip(".,;)")
+
+    for sec in sections:
+        sid = (sec.get("id") or "").lower()
+        stitle = (sec.get("title") or "").lower()
+        if "documentation" in sid or "documentation" in stitle:
+            for b in walk_blocks(sec.get("blocks")):
+                if b.get("type") == "link" and b.get("href"):
+                    doc_links.append({
+                        "title": b.get("title"),
+                        "url": b.get("href"),
+                        "description": b.get("description"),
+                    })
+                elif b.get("type") in ("markdown", "thumb-markdown"):
+                    for m in MDLINK_RE.finditer(b.get("content") or ""):
+                        doc_links.append({"title": m.group(1), "url": m.group(2),
+                                          "description": None})
+    for asec in aside_secs:
+        for b in walk_blocks(asec.get("blocks")):
+            bid = (b.get("id") or "").lower()
+            btitle = (b.get("title") or "").lower()
+            if bid in ("citation", "doi", "references") or "citation" in btitle:
+                content = b.get("content") or ""
+                if content:
+                    dois = sorted({clean_doi(d) for d in DOI_RE.findall(content)})
+                    references.append({
+                        "id": b.get("id"),
+                        "title": b.get("title"),
+                        "text": content,
+                        "dois": dois,
+                    })
+            # documentation links can also live in aside (rare)
+            if b.get("type") == "link" and b.get("href") and "doc" in bid:
+                doc_links.append({"title": b.get("title"), "url": b.get("href"),
+                                  "description": b.get("description")})
+    # dedupe doc links by url
+    seen = set()
+    uniq = []
+    for dl in doc_links:
+        if dl["url"] not in seen:
+            seen.add(dl["url"])
+            uniq.append(dl)
+    return uniq, references
+
+
+def main():
+    refs_out = {}
+    stats = {}
+    with httpx.Client(follow_redirects=True) as client:
+        for store in STORES:
+            with open(os.path.join(BASE, "raw", f"{store}_collections_full.json")) as f:
+                recs = json.load(f)
+            pdir = os.path.join(BASE, "raw", "pages", store)
+            os.makedirs(pdir, exist_ok=True)
+            refs_out[store] = {}
+            got, nolayout, failed = 0, [], []
+            for rec in recs:
+                cid = rec["id"]
+                layout_url = next((l["href"] for l in rec.get("links", [])
+                                   if l.get("rel") == "layout"), None)
+                if not layout_url:
+                    nolayout.append(cid)
+                    continue
+                path = os.path.join(pdir, f"{cid}.json")
+                if os.path.exists(path) and os.path.getsize(path) > 50:
+                    with open(path) as f:
+                        layout = json.load(f)
+                else:
+                    r = get(client, layout_url)
+                    if r is None:
+                        failed.append(cid)
+                        continue
+                    try:
+                        layout = r.json()
+                    except json.JSONDecodeError:
+                        failed.append(cid)
+                        continue
+                    with open(path, "w") as f:
+                        json.dump(layout, f)
+                got += 1
+                doc_links, references = extract_from_layout(layout)
+                refs_out[store][cid] = {
+                    "documentation_links": doc_links,
+                    "references": references,
+                }
+            stats[store] = {"total": len(recs), "layout_fetched": got,
+                            "no_layout_link": nolayout, "fetch_failed": failed}
+            print(f"{store}: {got}/{len(recs)} layouts; no-layout={len(nolayout)} "
+                  f"failed={len(failed)} {nolayout or ''}{failed or ''}", flush=True)
+
+    with open(os.path.join(BASE, "cds_references.json"), "w") as f:
+        json.dump(refs_out, f)
+    with open(os.path.join(BASE, "raw", "pages_harvest_stats.json"), "w") as f:
+        json.dump(stats, f, indent=1)
+    # coverage
+    for store in STORES:
+        vals = refs_out[store].values()
+        nrefs = sum(1 for v in vals if v["references"])
+        ndocs = sum(1 for v in vals if v["documentation_links"])
+        print(f"{store}: {nrefs}/{len(vals)} with references, {ndocs}/{len(vals)} with doc links")
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/05_enrich_stac.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+"""Build {cds,ads,ewds}_enriched.json from raw STAC records + layout extracts."""
+import json
+import os
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+STORES = ["cds", "ads", "ewds"]
+
+
+def main():
+    refs_path = os.path.join(BASE, "cds_references.json")
+    refs_all = {}
+    if os.path.exists(refs_path):
+        with open(refs_path) as f:
+            refs_all = json.load(f)
+
+    for store in STORES:
+        with open(os.path.join(BASE, "raw", f"{store}_collections_full.json")) as f:
+            recs = json.load(f)
+        srefs = refs_all.get(store, {})
+        out = {}
+        for r in recs:
+            cid = r["id"]
+            page = srefs.get(cid, {})
+            doc_links = [
+                {"title": dl.get("title"), "url": dl.get("url"),
+                 "rel": "documentation", "description": dl.get("description")}
+                for dl in page.get("documentation_links", [])
+            ]
+            # STAC-native doc-ish links
+            for l in r.get("links", []):
+                if l.get("rel") in ("documentation", "describedby", "cite-as", "license"):
+                    doc_links.append({"title": l.get("title"), "url": l.get("href"),
+                                      "rel": l.get("rel"), "description": None})
+            ext = r.get("extent") or {}
+            out[cid] = {
+                "id": cid,
+                "store": store,
+                "title": r.get("title"),
+                "description": r.get("description"),
+                "doi": r.get("sci:doi"),
+                "license": r.get("license"),
+                "update_frequency": r.get("cads:update_frequency"),
+                "disabled_reason": r.get("cads:disabled_reason"),
+                "message": r.get("cads:message"),
+                "providers": r.get("providers"),
+                "keywords": r.get("keywords"),
+                "published": r.get("published"),
+                "updated": r.get("updated"),
+                "assets": r.get("assets"),
+                "spatial_bbox": (ext.get("spatial") or {}).get("bbox"),
+                "temporal_interval": (ext.get("temporal") or {}).get("interval"),
+                "documentation_links": doc_links,
+                "references": page.get("references", []),
+                "related_collections": [
+                    l["href"].rstrip("/").rsplit("/", 1)[-1]
+                    for l in r.get("links", []) if l.get("rel") == "related"
+                ],
+            }
+        path = os.path.join(BASE, f"{store}_enriched.json")
+        with open(path, "w") as f:
+            json.dump(out, f)
+        n = len(out)
+        print(f"{store}: {n} collections -> {path}")
+        for field in ("doi", "license", "update_frequency", "documentation_links",
+                      "references", "published"):
+            c = sum(1 for v in out.values() if v.get(field))
+            print(f"   {field}: {c}/{n}")
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/06_unify.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+"""Merge all enriched artifacts into unified_metadata.json.
+
+Key = CMEMS dataset_id or CDS/ADS/EWDS collection id.
+Value = compact, JSON-serializable record for a `dataset_metadata` MCP tool.
+"""
+import json
+import os
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+
+CMEMS_LICENCE = ("Copernicus Marine Service Licence — "
+                 "https://marine.copernicus.eu/user-corner/service-commitments-and-licence")
+
+
+def load(name):
+    with open(os.path.join(BASE, name)) as f:
+        return json.load(f)
+
+
+def union_bbox(bboxes):
+    bbs = [b for b in bboxes if b and len(b) == 4 and all(isinstance(x, (int, float)) for x in b)]
+    if not bbs:
+        return None
+    return [min(b[0] for b in bbs), min(b[1] for b in bbs),
+            max(b[2] for b in bbs), max(b[3] for b in bbs)]
+
+
+def main():
+    products = load("cmems_products_enriched.json")
+    datasets = load("cmems_datasets_enriched.json")
+    unified = {}
+
+    for did, d in datasets.items():
+        p = products.get(d["product_id"], {})
+        variables = []
+        tmins, tmaxs, dmins, dmaxs = [], [], [], []
+        for v in d["variables"]:
+            dr = v.get("depth_range") or {}
+            tr = v.get("time_range")
+            variables.append({
+                "short_name": v.get("short_name"),
+                "standard_name": v.get("standard_name"),
+                "units": v.get("units"),
+                "bbox": v.get("bbox"),
+                "depth_range": ([dr.get("min"), dr.get("max")] if dr else None),
+                "time_range": tr,
+            })
+            if tr and tr[0] is not None and isinstance(tr[0], str):
+                tmins.append(tr[0])
+            if tr and tr[1] is not None and isinstance(tr[1], str):
+                tmaxs.append(tr[1])
+            if dr and isinstance(dr.get("min"), (int, float)):
+                dmins.append(dr["min"])
+            if dr and isinstance(dr.get("max"), (int, float)):
+                dmaxs.append(dr["max"])
+
+        doc_links = [{"title": "Copernicus Marine product page",
+                      "url": f"https://data.marine.copernicus.eu/product/{d['product_id']}/description",
+                      "rel": "documentation"}]
+        url_meta = None
+        for ver in d.get("versions", []):
+            for part in ver.get("parts", []):
+                if part.get("url_metadata"):
+                    url_meta = part["url_metadata"]
+                    break
+            if url_meta:
+                break
+        if url_meta:
+            doc_links.append({"title": "Dataset STAC metadata", "url": url_meta,
+                              "rel": "metadata"})
+
+        doi = d.get("digital_object_identifier") or p.get("digital_object_identifier")
+        references = []
+        if doi:
+            references.append({
+                "text": f"{p.get('production_center') or 'E.U. Copernicus Marine Service Information'}: "
+                        f"{p.get('title')} (product {d['product_id']}). DOI: {doi}",
+                "doi": doi,
+            })
+
+        unified[did] = {
+            "store": "cmems",
+            "product_id": d["product_id"],
+            "dataset_name": d.get("dataset_name"),
+            "title": p.get("title"),
+            "doi": doi,
+            "variables": variables,
+            "spatial_bbox": union_bbox([v.get("bbox") for v in d["variables"]]),
+            "temporal_range": [min(tmins) if tmins else None,
+                               max(tmaxs) if tmaxs else None],
+            "depth_range": ([min(dmins), max(dmaxs)] if dmins and dmaxs else None),
+            "update_frequency": None,  # not exposed by describe(); see GAPS.md
+            "processing_level": p.get("processing_level"),
+            "production_center": p.get("production_center"),
+            "sources": p.get("sources"),
+            "keywords": p.get("keywords"),
+            "latest_version": d.get("latest_version"),
+            "services": sorted({s.get("name") for s in d.get("services", []) if s.get("name")}),
+            "documentation_links": doc_links,
+            "references": references,
+            "licence": CMEMS_LICENCE,
+        }
+
+    for store in ("cds", "ads", "ewds"):
+        enr = load(f"{store}_enriched.json")
+        for cid, r in enr.items():
+            refs = []
+            for ref in r.get("references", []):
+                refs.append({
+                    "text": ref.get("text"),
+                    "doi": (ref.get("dois") or [None])[0],
+                    "title": ref.get("title"),
+                })
+            unified[cid] = {
+                "store": store,
+                "product_id": None,
+                "title": r.get("title"),
+                "doi": r.get("doi"),
+                "variables": None,  # form/constraints API needed; see GAPS.md
+                "spatial_bbox": (r.get("spatial_bbox") or [None])[0],
+                "temporal_range": (r.get("temporal_interval") or [None])[0],
+                "depth_range": None,
+                "update_frequency": r.get("update_frequency"),
+                "processing_level": None,
+                "production_center": ", ".join(pv.get("name", "") for pv in (r.get("providers") or [])) or None,
+                "sources": None,
+                "keywords": r.get("keywords"),
+                "published": r.get("published"),
+                "updated": r.get("updated"),
+                "message": r.get("message"),
+                "documentation_links": r.get("documentation_links"),
+                "references": refs,
+                "licence": r.get("license"),
+                "related_collections": r.get("related_collections"),
+            }
+
+    out = os.path.join(BASE, "unified_metadata.json")
+    with open(out, "w") as f:
+        json.dump(unified, f)
+    print(f"unified: {len(unified)} entries, {os.path.getsize(out)} bytes")
+    by_store = {}
+    for v in unified.values():
+        by_store[v["store"]] = by_store.get(v["store"], 0) + 1
+    print(by_store)
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/07_stats.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+"""Generate STATS.md coverage report from the produced artifacts."""
+import json
+import os
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+
+
+def load(name):
+    with open(os.path.join(BASE, name)) as f:
+        return json.load(f)
+
+
+def pct(n, d):
+    return f"{n}/{d} ({n/d:.0%})" if d else "0/0"
+
+
+def main():
+    lines = ["# STATS — Copernicus metadata harvest coverage", ""]
+
+    # CMEMS
+    products = load("cmems_products_enriched.json")
+    datasets = load("cmems_datasets_enriched.json")
+    np_, nd = len(products), len(datasets)
+    lines += [f"## CMEMS (Marine)", "",
+              f"- Products: **{np_}**, Datasets: **{nd}**", "",
+              "| field | coverage |", "|---|---|"]
+    for f_ in ("digital_object_identifier", "sources", "processing_level",
+               "production_center", "keywords", "thumbnail_url"):
+        c = sum(1 for p in products.values() if p.get(f_))
+        lines.append(f"| product.{f_} | {pct(c, np_)} |")
+    for f_ in ("latest_version", "services", "variables"):
+        c = sum(1 for d in datasets.values() if d.get(f_))
+        lines.append(f"| dataset.{f_} | {pct(c, nd)} |")
+    c = sum(1 for d in datasets.values()
+            for v in d.get("versions", []) for pt in v.get("parts", [])
+            if pt.get("released_date")) and sum(
+        1 for d in datasets.values() if any(
+            pt.get("released_date") for v in d.get("versions", [])
+            for pt in v.get("parts", [])))
+    lines.append(f"| dataset has released_date | {pct(c, nd)} |")
+    c = sum(1 for d in datasets.values() if any(
+        pt.get("url_metadata") for v in d.get("versions", [])
+        for pt in v.get("parts", [])))
+    lines.append(f"| dataset has url_metadata | {pct(c, nd)} |")
+    allvars = [v for d in datasets.values() for v in d["variables"]]
+    nv = len(allvars)
+    lines += ["", f"- Variables (latest version, deduped): **{nv}**", "",
+              "| variable field | coverage |", "|---|---|"]
+    for f_ in ("units", "standard_name", "bbox", "time_range", "depth_range"):
+        c = sum(1 for v in allvars if v.get(f_))
+        lines.append(f"| {f_} | {pct(c, nv)} |")
+    lines.append("")
+
+    # CDS/ADS/EWDS
+    for store in ("cds", "ads", "ewds"):
+        enr = load(f"{store}_enriched.json")
+        n = len(enr)
+        lines += [f"## {store.upper()}", "", f"- Collections: **{n}**", "",
+                  "| field | coverage |", "|---|---|"]
+        for f_ in ("doi", "license", "update_frequency", "providers", "keywords",
+                   "published", "updated", "assets", "spatial_bbox",
+                   "temporal_interval", "documentation_links", "references",
+                   "variables", "message"):
+            c = sum(1 for v in enr.values() if v.get(f_))
+            lines.append(f"| {f_} | {pct(c, n)} |")
+        ndl = sum(len(v.get("documentation_links") or []) for v in enr.values())
+        nrf = sum(len(v.get("references") or []) for v in enr.values())
+        ndoi_in_refs = sum(1 for v in enr.values()
+                           if any(r.get("dois") for r in v.get("references") or []))
+        lines += [f"| total doc links | {ndl} |",
+                  f"| total reference blocks | {nrf} |",
+                  f"| refs containing a DOI | {pct(ndoi_in_refs, n)} |", ""]
+
+    # unified
+    uni = load("unified_metadata.json")
+    lines += ["## Unified", "",
+              f"- unified_metadata.json entries: **{len(uni)}** "
+              f"(cmems={sum(1 for v in uni.values() if v['store']=='cmems')}, "
+              f"cds={sum(1 for v in uni.values() if v['store']=='cds')}, "
+              f"ads={sum(1 for v in uni.values() if v['store']=='ads')}, "
+              f"ewds={sum(1 for v in uni.values() if v['store']=='ewds')})", ""]
+    for f_ in ("doi", "keywords", "documentation_links", "references", "licence",
+               "update_frequency", "spatial_bbox", "variables"):
+        c = sum(1 for v in uni.values() if v.get(f_))
+        lines.append(f"- {f_}: {pct(c, len(uni))}")
+    c = sum(1 for v in uni.values()
+            if v.get("temporal_range") and any(x is not None for x in v["temporal_range"]))
+    lines.append(f"- temporal_range (non-null): {pct(c, len(uni))}")
+
+    # bytes
+    lines += ["", "## Harvest volume", ""]
+    total = 0
+    for root, _, files in os.walk(BASE):
+        for fn in files:
+            if fn.endswith((".json", ".html")):
+                total += os.path.getsize(os.path.join(root, fn))
+    lines.append(f"- Total bytes of JSON artifacts (incl. raw): **{total:,}**")
+
+    with open(os.path.join(BASE, "STATS.md"), "w") as f:
+        f.write("\n".join(lines) + "\n")
+    print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/08_harvest_forms.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+"""Fetch the 'form' JSON per collection (CDS/ADS/EWDS) and extract the
+selectable variable names. Saves raw/pages/{store}/{id}.form.json and
+updates {store}_enriched.json + unified_metadata.json with variables[].
+"""
+import json
+import os
+import time
+
+import httpx
+
+BASE = "/Users/dmpantiu/copernicus_mcp/meta_harvest"
+STORES = ["cds", "ads", "ewds"]
+HEADERS = {"User-Agent": "meta-harvest/1.0 (research; contact: local)"}
+MIN_INTERVAL = 0.5
+_last = {}
+
+
+def get_json(client, url):
+    host = url.split("/")[2]
+    for attempt in range(6):
+        w = MIN_INTERVAL - (time.time() - _last.get(host, 0))
+        if w > 0:
+            time.sleep(w)
+        try:
+            _last[host] = time.time()
+            r = client.get(url, headers=HEADERS, timeout=60)
+            if r.status_code == 200:
+                return r.json()
+            if r.status_code in (429, 500, 502, 503, 504):
+                time.sleep(2 ** attempt)
+                continue
+            return None
+        except (httpx.HTTPError, json.JSONDecodeError):
+            time.sleep(2 ** attempt)
+    return None
+
+
+def widget_values(details):
+    vals = []
+    if not isinstance(details, dict):
+        return vals
+    if isinstance(details.get("values"), list):
+        vals.extend(v for v in details["values"] if isinstance(v, str))
+    for g in details.get("groups") or []:
+        if isinstance(g, dict):
+            vals.extend(widget_values(g))
+            if isinstance(g.get("values"), list):
+                pass  # handled by recursion? groups don't recurse via details
+    # groups may nest: {label, values} or {label, groups}
+    return vals
+
+
+def collect_group_values(obj):
+    vals = []
+    if isinstance(obj, dict):
+        if isinstance(obj.get("values"), list):
+            vals.extend(v for v in obj["values"] if isinstance(v, str))
+        for g in obj.get("groups") or []:
+            vals.extend(collect_group_values(g))
+    return vals
+
+
+def extract_variables(form):
+    if not isinstance(form, list):
+        return []
+    out = []
+    for w in form:
+        name = (w.get("name") or "").lower()
+        if name != "variable" and "variable" not in name:
+            continue
+        details = w.get("details") or {}
+        vals = collect_group_values(details)
+        labels = details.get("labels")
+        if not vals and isinstance(labels, dict):
+            vals = list(labels.keys())
+        out.extend(vals)
+    # dedupe preserving order
+    seen, uniq = set(), []
+    for v in out:
+        if v not in seen:
+            seen.add(v)
+            uniq.append(v)
+    return uniq
+
+
+def main():
+    var_map = {}  # store -> cid -> [variables]
+    with httpx.Client(follow_redirects=True) as client:
+        for store in STORES:
+            with open(os.path.join(BASE, "raw", f"{store}_collections_full.json")) as f:
+                recs = json.load(f)
+            pdir = os.path.join(BASE, "raw", "pages", store)
+            var_map[store] = {}
+            noform, failed = [], []
+            for rec in recs:
+                cid = rec["id"]
+                form_url = next((l["href"] for l in rec.get("links", [])
+                                 if l.get("rel") == "form"), None)
+                if not form_url:
+                    noform.append(cid)
+                    continue
+                path = os.path.join(pdir, f"{cid}.form.json")
+                if os.path.exists(path) and os.path.getsize(path) > 10:
+                    with open(path) as f:
+                        form = json.load(f)
+                else:
+                    form = get_json(client, form_url)
+                    if form is None:
+                        failed.append(cid)
+                        continue
+                    with open(path, "w") as f:
+                        json.dump(form, f)
+                var_map[store][cid] = extract_variables(form)
+            nvars = sum(1 for v in var_map[store].values() if v)
+            print(f"{store}: forms ok={len(var_map[store])}, with variables={nvars}, "
+                  f"no-form-link={len(noform)}, failed={len(failed)}", flush=True)
+            if noform:
+                print(f"  no form link: {noform}")
+            if failed:
+                print(f"  failed: {failed}")
+
+    # patch enriched + unified
+    uni_path = os.path.join(BASE, "unified_metadata.json")
+    with open(uni_path) as f:
+        uni = json.load(f)
+    for store in STORES:
+        epath = os.path.join(BASE, f"{store}_enriched.json")
+        with open(epath) as f:
+            enr = json.load(f)
+        for cid, vs in var_map[store].items():
+            if cid in enr:
+                enr[cid]["variables"] = vs
+            if cid in uni:
+                uni[cid]["variables"] = [{"short_name": v} for v in vs] if vs else None
+        with open(epath, "w") as f:
+            json.dump(enr, f)
+    with open(uni_path, "w") as f:
+        json.dump(uni, f)
+    n = sum(1 for v in uni.values() if v["store"] != "cmems" and v.get("variables"))
+    print(f"unified: {n} CDS/ADS/EWDS entries now have variables")
+
+
+if __name__ == "__main__":
+    main()

scripts/meta_harvest/GAPS.md

@@ -0,0 +1,74 @@
+# GAPS — what upstream still cannot provide programmatically
+
+Harvest date: 2026-07-02. All catalogue reads were anonymous (no credentials).
+
+## CMEMS (Marine Data Store)
+
+- **115/1269 datasets have zero variable metadata** (no short_name/units/bounds).
+  These are exposed upstream only through the `original-files` (native S3) service
+  with an empty `variables[]` list — mostly OCEANCOLOUR (62), SEAICE (17), WAVE (12),
+  INSITU (7) climatology / in-situ / irregular-grid datasets. Verified that *no*
+  version (not just the latest) carries variables; the only recourse would be
+  opening the actual NetCDF files, which is out of scope for a catalogue harvest.
+- **`units` missing for ~5% of variables, `standard_name` for ~14%** — absent in
+  the upstream describe() payload itself (typically OMI/insitu variables with no
+  CF standard name).
+- **`depth_range` only on ~30% of variables** — correct behaviour: most datasets
+  are surface-only; but describe() does not distinguish "surface-only" from
+  "depth axis not described".
+- **`update_frequency` is not exposed** anywhere in `copernicusmarine.describe()`.
+  It exists only in the per-dataset STAC (`url_metadata` → dataset.stac.json,
+  `properties.cmems_arco:updateFrequency` on some) and on the product web page.
+  Not harvested (would be ~1300 extra requests); `url_metadata` links are saved in
+  `cmems_datasets_enriched.json` so it can be back-filled later.
+- **Licence text**: describe() carries no licence field. The Copernicus Marine
+  Service Licence is uniform across all products, so `unified_metadata.json`
+  records the canonical licence URL as a constant, not a harvested value.
+- **Citation text**: CMEMS provides no formatted citation via API; the reference
+  entries in `unified_metadata.json` for CMEMS are synthesized from
+  production_center + title + DOI (DOI itself is upstream data).
+- **1 product without DOI or keywords**: `NWATL_ANALYSISFORECAST_PHY_ICE_017_001`
+  (checked: both fields are null upstream).
+- **`released_date` present for only 74% of dataset version-parts** — null upstream
+  for older versions released before the field was introduced.
+- **`processing_level` null for 88/307 products** — null upstream (mostly OMIs and
+  model products where the concept does not apply).
+
+## CDS / ADS / EWDS (Climate / Atmosphere / Emergency Data Stores)
+
+- Web pages are React shells; the actual "Documentation" and "References/Citation"
+  content is served from the **`rel="layout"` JSON** linked from each STAC record
+  (object store, anonymous). All 167/167 layouts were fetched — no HTML scraping
+  was needed, so no page-level gap remains.
+- **`provider-c3s-data-rescue-without` (CDS)** is the single collection with no
+  documentation links, no references, no DOI, no keywords and no form: it is a
+  provider landing page, not a dataset.
+- **DOI missing for 6 CDS collections** (null upstream): the five `*-timeseries`
+  spin-offs (`reanalysis-era5-land-timeseries`, `reanalysis-era5-single-levels-timeseries`,
+  `derived-utci-historical-timeseries`, `reanalysis-oras5-timeseries`,
+  `sis-ecde-climate-indicators`) and `provider-c3s-data-rescue-without`.
+  Their citation blocks point to the parent dataset's DOI where one exists.
+- **`update_frequency` (`cads:update_frequency`) null for 32/139 CDS and 14/16 ADS
+  collections** — the field simply isn't populated upstream for those records.
+- **Variable lists for CDS/ADS/EWDS come from the download `form` JSON**
+  (`rel="form"`): names only — the form carries **no units, standard_names, or
+  per-variable bounds**. 3 dataset collections have a form without a "variable"
+  widget: `reanalysis-era5-complete` and `reanalysis-uerra-europe-complete`
+  (MARS-native datasets where variables are free-form `param` codes) and
+  `cams-solar-radiation-timeseries` (single implicit product). Recorded with
+  `variables: null` in `unified_metadata.json`.
+  Full per-variable physics would require parsing each dataset's Confluence/user-guide
+  PDF — out of scope.
+- **`cads:message`** (service messages) present for only 7 CDS + 2 ADS collections —
+  that is genuine (messages exist only when there is an active notice).
+- No per-dataset **spatial resolution / grid** field exists in the STAC record;
+  it lives only in free-text "Data description" tables inside the layout JSON
+  (kept verbatim in `raw/pages/{store}/{id}.json` if needed later).
+
+## General
+
+- CMEMS `describe()` output is a point-in-time snapshot (~63 MB); temporal ranges
+  of forecast products (e.g. max time 2026-07-10) move daily. Re-run
+  `01_dump_cmems.py` (delete the raw file first) to refresh.
+- No API exposes cross-store product lineage (e.g. which CMEMS product feeds a
+  C3S indicator); `related_collections` links exist only within a single store.

scripts/meta_harvest/STATS.md

@@ -0,0 +1,119 @@
+# STATS — Copernicus metadata harvest coverage
+
+## CMEMS (Marine)
+
+- Products: **307**, Datasets: **1269**
+
+| field | coverage |
+|---|---|
+| product.digital_object_identifier | 306/307 (100%) |
+| product.sources | 307/307 (100%) |
+| product.processing_level | 219/307 (71%) |
+| product.production_center | 307/307 (100%) |
+| product.keywords | 306/307 (100%) |
+| product.thumbnail_url | 307/307 (100%) |
+| dataset.latest_version | 1269/1269 (100%) |
+| dataset.services | 1269/1269 (100%) |
+| dataset.variables | 1154/1269 (91%) |
+| dataset has released_date | 943/1269 (74%) |
+| dataset has url_metadata | 1269/1269 (100%) |
+
+- Variables (latest version, deduped): **8567**
+
+| variable field | coverage |
+|---|---|
+| units | 8155/8567 (95%) |
+| standard_name | 7406/8567 (86%) |
+| bbox | 8567/8567 (100%) |
+| time_range | 8042/8567 (94%) |
+| depth_range | 2583/8567 (30%) |
+
+## CDS
+
+- Collections: **139**
+
+| field | coverage |
+|---|---|
+| doi | 133/139 (96%) |
+| license | 139/139 (100%) |
+| update_frequency | 107/139 (77%) |
+| providers | 137/139 (99%) |
+| keywords | 138/139 (99%) |
+| published | 139/139 (100%) |
+| updated | 139/139 (100%) |
+| assets | 139/139 (100%) |
+| spatial_bbox | 139/139 (100%) |
+| temporal_interval | 139/139 (100%) |
+| documentation_links | 138/139 (99%) |
+| references | 138/139 (99%) |
+| variables | 136/139 (98%) |
+| message | 7/139 (5%) |
+| total doc links | 1123 |
+| total reference blocks | 269 |
+| refs containing a DOI | 134/139 (96%) |
+
+## ADS
+
+- Collections: **16**
+
+| field | coverage |
+|---|---|
+| doi | 16/16 (100%) |
+| license | 16/16 (100%) |
+| update_frequency | 2/16 (12%) |
+| providers | 16/16 (100%) |
+| keywords | 16/16 (100%) |
+| published | 16/16 (100%) |
+| updated | 16/16 (100%) |
+| assets | 16/16 (100%) |
+| spatial_bbox | 16/16 (100%) |
+| temporal_interval | 16/16 (100%) |
+| documentation_links | 16/16 (100%) |
+| references | 16/16 (100%) |
+| variables | 15/16 (94%) |
+| message | 2/16 (12%) |
+| total doc links | 53 |
+| total reference blocks | 32 |
+| refs containing a DOI | 16/16 (100%) |
+
+## EWDS
+
+- Collections: **12**
+
+| field | coverage |
+|---|---|
+| doi | 12/12 (100%) |
+| license | 12/12 (100%) |
+| update_frequency | 12/12 (100%) |
+| providers | 12/12 (100%) |
+| keywords | 12/12 (100%) |
+| published | 12/12 (100%) |
+| updated | 12/12 (100%) |
+| assets | 12/12 (100%) |
+| spatial_bbox | 12/12 (100%) |
+| temporal_interval | 12/12 (100%) |
+| documentation_links | 12/12 (100%) |
+| references | 12/12 (100%) |
+| variables | 12/12 (100%) |
+| message | 0/12 (0%) |
+| total doc links | 58 |
+| total reference blocks | 24 |
+| refs containing a DOI | 12/12 (100%) |
+
+## Unified
+
+- unified_metadata.json entries: **1436** (cmems=1269, cds=139, ads=16, ewds=12)
+
+- doi: 1422/1436 (99%)
+- keywords: 1427/1436 (99%)
+- documentation_links: 1435/1436 (100%)
+- references: 1427/1436 (99%)
+- licence: 1436/1436 (100%)
+- update_frequency: 121/1436 (8%)
+- spatial_bbox: 1321/1436 (92%)
+- variables: 1317/1436 (92%)
+- temporal_range (non-null): 1228/1436 (86%)
+
+## Harvest volume
+
+- Total bytes of JSON artifacts (incl. raw): **87,820,588**

scripts/notebook_harvest/parse_gallery.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Code-preserving parse of copernicus-marine-notebook-gallery notebooks.
+Reuses the extract_code.py pattern: verbatim markdown + verbatim ```python
+code cells + trimmed ```text outputs; classify recipe_kinds via regex.
+Writes parsed/<name>/<notebook_id>.md and prints a JSON manifest to stdout.
+"""
+import json, re, sys
+from pathlib import Path
+
+REPO = Path("/Users/dmpantiu/copernicus_mcp/notebook_harvest/repos/copernicus-marine-notebook-gallery")
+OUT = Path("/Users/dmpantiu/copernicus_mcp/notebook_harvest/parsed/copernicus-marine-notebook-gallery")
+ROOT = Path("/Users/dmpantiu/copernicus_mcp")
+
+DOWNLOAD_RE = re.compile(
+    r"cdsapi|\.retrieve\(|copernicusmarine|\bcm\.(subset|get|open_dataset)|"
+    r"motuclient|--service-id|--product-id|!?\bwget\b|urlretrieve|requests\.get|\.hda\b|EO:",
+    re.I)
+ANALYZE_RE = re.compile(
+    r"\bimport xarray|\bxr\.|\.open_dataset|\.open_mfdataset|\bimport pandas|\bpd\.|"
+    r"\bimport numpy|\bnp\.|\bscipy|nc\.Dataset|netCDF4|\.groupby\(|\.resample\(|"
+    r"\.mean\(|\.sel\(|\.isel\(", re.I)
+PLOT_RE = re.compile(
+    r"\bmatplotlib|\bplt\.|\bcartopy|\bccrs\b|\bcmocean|\.plot\(|\.plot\.|seaborn|\bsns\.|pcolor|contourf",
+    re.I)
+
+
+def _src(cell):
+    s = cell.get("source", "")
+    return "".join(s) if isinstance(s, list) else s
+
+
+def code_line_count(code):
+    n = 0
+    for ln in code.splitlines():
+        st = ln.strip()
+        if st and not st.startswith("#"):
+            n += 1
+    return n
+
+
+def text_outputs(cell):
+    out = []
+    for o in cell.get("outputs", []):
+        ot = o.get("output_type"); s = None
+        if ot == "stream":
+            t = o.get("text", ""); s = "".join(t) if isinstance(t, list) else t
+        elif ot in ("execute_result", "display_data"):
+            tp = (o.get("data") or {}).get("text/plain")
+            if tp is not None:
+                s = "".join(tp) if isinstance(tp, list) else tp
+        if not s:
+            continue
+        s = s.strip()
+        if not s or re.fullmatch(r"<[^>]+>", s) or s.startswith("<Figure"):
+            continue
+        lines = [ln for ln in s.splitlines()
+                 if "%|" not in ln and "it/s]" not in ln and "B/s]" not in ln]
+        s = "\n".join(lines).strip()
+        if len(s) >= 8:
+            out.append(s[:1500])
+    return out
+
+
+def classify(code):
+    kinds = []
+    if DOWNLOAD_RE.search(code): kinds.append("download")
+    if ANALYZE_RE.search(code): kinds.append("analyze")
+    if PLOT_RE.search(code): kinds.append("plot")
+    return kinds or ["other"]
+
+
+def slug(path):
+    return re.sub(r"[^A-Za-z0-9._-]+", "-", path.stem).strip("-")
+
+
+def extract(path):
+    nb = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    parts = []; n_cells = 0; n_lines = 0; kinds = set(); title = ""
+    for cell in nb.get("cells", []):
+        ct = cell.get("cell_type")
+        if ct == "markdown":
+            txt = _src(cell).strip()
+            if txt:
+                parts.append(txt)
+                if not title:
+                    for ln in txt.splitlines():
+                        if ln.startswith("# "):
+                            title = ln[2:].strip(); break
+        elif ct == "code":
+            src = _src(cell).rstrip()
+            if not src.strip():
+                continue
+            n_cells += 1; n_lines += code_line_count(src)
+            kinds.update(classify(src))
+            parts.append("```python\n" + src + "\n```")
+            for to in text_outputs(cell):
+                parts.append("```text\n" + to + "\n```")
+    return {"md": "\n\n".join(parts).strip(), "title": title or path.stem,
+            "n_code_cells": n_cells, "n_code_lines": n_lines,
+            "recipe_kinds": sorted(kinds)}
+
+
+def main():
+    OUT.mkdir(parents=True, exist_ok=True)
+    recs = []
+    for nb in sorted(REPO.rglob("*.ipynb")):
+        if ".ipynb_checkpoints" in nb.parts:
+            continue
+        nid = slug(nb)
+        ex = extract(nb)
+        if ex["n_code_cells"] == 0:
+            print(f"SKIP prose-only: {nid}", file=sys.stderr); continue
+        md = OUT / f"{nid}.md"
+        md.write_text(ex["md"], encoding="utf-8")
+        recs.append({
+            "notebook_id": nid, "title": ex["title"],
+            "src_path": str(nb.relative_to(REPO)),
+            "md_path": str(md.relative_to(ROOT)),
+            "n_code_cells": ex["n_code_cells"], "n_code_lines": ex["n_code_lines"],
+            "recipe_kinds": ex["recipe_kinds"],
+        })
+    print(json.dumps(recs, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/notebook_harvest/parse_instac.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Code-preserving parse + dataset mapping for CopernicusMarineInsitu/INSTACTraining."""
+import json, re, sys
+from pathlib import Path
+
+REPO = Path("/Users/dmpantiu/copernicus_mcp/notebook_harvest/repos/INSTACTraining")
+OUT = Path("/Users/dmpantiu/copernicus_mcp/notebook_harvest/parsed/INSTACTraining")
+CATALOG = Path("/Users/dmpantiu/copernicus_mcp/marine_rag/out/catalog.json")
+
+DOWNLOAD_RE = re.compile(
+    r"cdsapi|\.retrieve\(|copernicusmarine|\bcm\.(subset|get|open_dataset)|"
+    r"motuclient|!?\bwget\b|!?\bcurl\b|urlretrieve|requests\.get|\bftplib\b|"
+    r"FTP\(|\.hda\b|urlopen|ftp://", re.I)
+ANALYZE_RE = re.compile(
+    r"\bimport xarray|\bxr\.|\.open_dataset|\.open_mfdataset|\bimport pandas|\bpd\.|"
+    r"\bimport numpy|\bnp\.|\bnetCDF4|\bDataset\(|\bscipy|\.groupby\(|\.resample\(|"
+    r"\.mean\(|\.sel\(|\.isel\(", re.I)
+PLOT_RE = re.compile(
+    r"\bmatplotlib|\bplt\.|\bcartopy|\bccrs\b|\bcmocean|\.plot\(|\.plot\.|seaborn|"
+    r"\bsns\.|\bfolium\b|basemap|\bBasemap\b", re.I)
+
+# product id patterns (legacy + current)
+PID_RE = re.compile(r"INSITU_[A-Z]+_[A-Z_]*?OBSERVATIONS_0\d\d_\d\d\d(?:_[a-z])?|"
+                    r"INSITU_[A-Z]+_[A-Z_]+_0\d\d_\d\d\d", re.I)
+DSID_RE = re.compile(r"cmems_obs-ins_[a-z0-9_-]+", re.I)
+SUFFIX_RE = re.compile(r"(0\d\d_\d\d\d)")
+
+# CMEMS INSTAC platform-file naming convention: <REGION>_<DATATYPE>_<PLATFORM>_<id>.nc
+# region prefix (first token) -> regional DISCRETE_MYNRT product numeric suffix
+REGION2SUFFIX = {"GL": "013_030", "AR": "013_031", "BO": "013_032", "BS": "013_034",
+                 "IR": "013_033", "IB": "013_033", "MO": "013_035", "NO": "013_036"}
+FILENAME_RE = re.compile(
+    r"\b(GL|AR|BO|BS|IR|IB|MO|NO)_(TS|PR|WS|CT|GL|TG|SF|WV|RF|HF)_[A-Z]{2}_[A-Za-z0-9_]+\.nc")
+
+
+def _src(cell):
+    s = cell.get("source", "")
+    return "".join(s) if isinstance(s, list) else s
+
+
+def code_line_count(code):
+    return sum(1 for ln in code.splitlines()
+               if ln.strip() and not ln.strip().startswith("#"))
+
+
+def text_outputs(cell):
+    out = []
+    for o in cell.get("outputs", []):
+        ot = o.get("output_type"); s = None
+        if ot == "stream":
+            t = o.get("text", ""); s = "".join(t) if isinstance(t, list) else t
+        elif ot in ("execute_result", "display_data"):
+            tp = (o.get("data") or {}).get("text/plain")
+            if tp is not None:
+                s = "".join(tp) if isinstance(tp, list) else tp
+        if not s:
+            continue
+        s = s.strip()
+        if not s or re.fullmatch(r"<[^>]+>", s) or s.startswith("<Figure"):
+            continue
+        lines = [ln for ln in s.splitlines()
+                 if "%|" not in ln and "it/s]" not in ln and "B/s]" not in ln]
+        s = "\n".join(lines).strip()
+        if len(s) >= 8:
+            out.append(s[:1500])
+    return out
+
+
+def classify(code):
+    kinds = []
+    if DOWNLOAD_RE.search(code): kinds.append("download")
+    if ANALYZE_RE.search(code): kinds.append("analyze")
+    if PLOT_RE.search(code): kinds.append("plot")
+    return kinds or ["other"]
+
+
+def slug(path):
+    rel = path.relative_to(REPO).with_suffix("")
+    return "__".join(rel.parts).replace(" ", "_")
+
+
+def extract_notebook(path):
+    nb = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    parts, n_code_cells, n_code_lines = [], 0, 0
+    kinds, title = set(), ""
+    raw_all = []
+    for cell in nb.get("cells", []):
+        ct = cell.get("cell_type")
+        if ct == "markdown":
+            txt = _src(cell).strip()
+            if txt:
+                parts.append(txt); raw_all.append(txt)
+                if not title:
+                    for ln in txt.splitlines():
+                        if ln.startswith("# "):
+                            title = ln[2:].strip(); break
+        elif ct == "code":
+            src = _src(cell).rstrip()
+            if not src.strip():
+                continue
+            n_code_cells += 1
+            n_code_lines += code_line_count(src)
+            kinds.update(classify(src))
+            raw_all.append(src)
+            parts.append("```python\n" + src + "\n```")
+            for to in text_outputs(cell):
+                parts.append("```text\n" + to + "\n```")
+                raw_all.append(to)
+    return {
+        "content_md": "\n\n".join(parts).strip(),
+        "title": title or path.stem,
+        "n_code_cells": n_code_cells,
+        "n_code_lines": n_code_lines,
+        "recipe_kinds": sorted(kinds),
+        "raw": "\n".join(raw_all),
+    }
+
+
+def main():
+    OUT.mkdir(parents=True, exist_ok=True)
+    catalog = json.load(open(CATALOG))
+    suffix2pid = {}
+    valid_pids = set()
+    dsid2pid = {}
+    for e in catalog:
+        pid = e.get("product_id")
+        if not pid:
+            continue
+        valid_pids.add(pid)
+        m = SUFFIX_RE.search(pid)
+        if m:
+            suffix2pid.setdefault(m.group(1), pid)
+        for ds in (e.get("dataset_ids") or []):
+            dsid2pid[ds] = pid
+
+    records = []
+    nbs = sorted(p for p in REPO.rglob("*.ipynb")
+                 if ".ipynb_checkpoints" not in p.parts)
+    for nb in nbs:
+        ex = extract_notebook(nb)
+        nid = slug(nb)
+        if ex["n_code_cells"] == 0:
+            print(f"SKIP prose-only: {nid}", file=sys.stderr)
+            continue
+        (OUT / f"{nid}.md").write_text(ex["content_md"], encoding="utf-8")
+
+        raw = ex["raw"]
+        found_pids = set()
+        raw_ids = set()
+        for m in PID_RE.findall(raw):
+            raw_ids.add(m)
+            sm = SUFFIX_RE.search(m)
+            if sm and sm.group(1) in suffix2pid:
+                found_pids.add(suffix2pid[sm.group(1)])
+        for m in DSID_RE.findall(raw):
+            raw_ids.add(m)
+            if m in dsid2pid:
+                found_pids.add(dsid2pid[m])
+        # fallback: infer product from INSTAC platform-file naming convention
+        if not found_pids:
+            for region, dtype in FILENAME_RE.findall(raw):
+                suf = REGION2SUFFIX.get(region.upper())
+                if suf and suf in suffix2pid:
+                    found_pids.add(suffix2pid[suf])
+                    fm = FILENAME_RE.search(raw)
+                    if fm:
+                        raw_ids.add("file:" + fm.group(0))
+        matched = sorted(found_pids)
+        scope = "dataset" if matched else "generic"
+        records.append({
+            "notebook_id": nid,
+            "title": ex["title"],
+            "matched_dataset_ids": matched,
+            "raw_ids": sorted(raw_ids),
+            "store": "CMEMS in-situ",
+            "scope": scope,
+            "source_repo": "CopernicusMarineInsitu/INSTACTraining",
+            "license": "MIT",
+            "src_path": str(nb.relative_to(REPO)),
+            "md_path": f"notebook_harvest/parsed/INSTACTraining/{nid}.md",
+            "n_code_cells": ex["n_code_cells"],
+            "n_code_lines": ex["n_code_lines"],
+            "recipe_kinds": ex["recipe_kinds"],
+        })
+
+    print(json.dumps(records, indent=2))
+    tot_lines = sum(r["n_code_lines"] for r in records)
+    print(f"\nNOTEBOOKS={len(records)} TOTAL_CODE_LINES={tot_lines}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()