rag_server: read_publication finds the shipped originals, falls back to honest chunk reassembly; get_dataset_code resolves notebooks under the published layout (WP3)

scripts/marine_rag/rag_server.py

@@ -855,13 +855,96 @@ def get_dataset_publications(dataset_or_product_id: str, top_k: int = 15) -> dic
         return _err(f"lookup failed: {repr(e)[:200]}")
 
 
+_CHUNK_CAP = 4000       # far above the corpus maximum of 670 chunks in one paper; a guard, not a policy
+_ORDER_UNKNOWN = 1 << 30    # sorts after every real index: an unordered chunk goes to the end, visibly
+
+
+def _chunk_order(chunk: dict) -> int:
+    """The chunk's position in its paper.
+
+    An explicit `chunk_index` payload field wins when present (the newer chunkers — chunk_papers_lib.py —
+    emit content-hash chunk ids and keep the order there). Failing that, the numeric tail of `chunk_id`
+    (`<paper_id>__<idx:03d>`, chunk_pubs.py — the scheme of the currently served corpus). A chunk with
+    neither sorts to the END rather than silently to the front: a reassembly that cannot order its pieces
+    must not present them as the document's order.
+    """
+    ci = chunk.get("chunk_index")
+    if isinstance(ci, int) and not isinstance(ci, bool):
+        return ci
+    if isinstance(ci, str) and ci.isdigit():
+        return int(ci)
+    cid = str(chunk.get("chunk_id") or "")
+    tail = cid.rsplit("__", 1)[-1]
+    return int(tail) if tail.isdigit() else _ORDER_UNKNOWN
+
+
+_PUB_CHUNK_CACHE: dict[str, tuple[list[dict], bool]] = {}
+
+
+def _publication_chunks(key: str) -> tuple[list[dict], bool, str | None]:
+    """Every chunk of one publication, in document order, by an exact payload filter — no query, no ranking,
+    no embedding. Returns (chunks, truncated, error).
+
+    `error` is non-None when the store could not be read: an infrastructure failure must stay
+    distinguishable from "this paper has no chunks", or a transient Qdrant outage silently reads as
+    "not parsed yet" (review finding). Results are cached per paper, because read_publication is paginated
+    and re-scrolling ~1.7 MB for every 20 kB page would move the whole paper once per page.
+
+    Server only: in embedded mode this collection is the one measured at over 24 GB resident without
+    answering inside 14 minutes, and reading a paper must not cost that.
+    """
+    if key in _PUB_CHUNK_CACHE:
+        chunks, truncated = _PUB_CHUNK_CACHE[key]
+        return chunks, truncated, None
+    try:
+        client = _via_server(PUBS_COLLECTION)
+        if client is None:
+            return [], False, None          # no server configured: an honest miss, not an error
+        out, offset = [], None
+        while True:
+            points, offset = client.scroll(
+                PUBS_COLLECTION, limit=256, offset=offset, with_payload=True,
+                scroll_filter=models.Filter(should=[
+                    models.FieldCondition(key="doi", match=models.MatchValue(value=key)),
+                    models.FieldCondition(key="paper_id", match=models.MatchValue(value=key))]))
+            out += [dict(p.payload or {}) for p in points]
+            if offset is None:
+                break
+            if len(out) >= 4 * _CHUNK_CAP:
+                break                       # runaway guard only; the real cap is applied AFTER sorting
+    except Exception as e:
+        _log(f"publication chunk scroll failed for {key}: {repr(e)[:120]}")
+        return [], False, f"publications store unreadable while collecting chunks: {repr(e)[:120]}"
+    if out:
+        # one paper only: the should-filter would merge chunks of paper A (matched by doi) with paper B
+        # (matched by paper_id) if a key ever named both — keep the paper the first chunk belongs to
+        own = out[0].get("paper_id")
+        if own:
+            out = [c for c in out if c.get("paper_id") == own]
+    out = sorted(out, key=_chunk_order)
+    truncated = len(out) > _CHUNK_CAP
+    if truncated:
+        out = out[:_CHUNK_CAP]              # after sorting: a truncated TAIL, never holes in the middle
+    if len(_PUB_CHUNK_CACHE) >= 8:
+        _PUB_CHUNK_CACHE.pop(next(iter(_PUB_CHUNK_CACHE)))
+    _PUB_CHUNK_CACHE[key] = (out, truncated)
+    return out, truncated, None
+
+
 @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.
+    """Pull the text of one publication, paginated (same contract as
+    read_document: page 0 includes a heading outline). Three outcomes, told
+    apart by `text_fidelity`:
+      • "verbatim"            — the parsed markdown original (full_text=true).
+      • "reconstructed-lossy" — no original on disk; the text is reassembled
+        from the publication's indexed chunks (full_text=FALSE: stored chunks
+        are capped at 2500 chars — cuts are marked in the text — references,
+        acknowledgements and similar sections were dropped at chunking, and
+        chunk overlap may repeat a sentence at seams).
+      • "metadata-only"       — nothing parsed and nothing indexed: registry
+        metadata + abstract.
 
     Args:
         doi_or_paper_id: canonical DOI ("10.x/...") or underscored paper_id.
@@ -871,12 +954,32 @@ def read_publication(doi_or_paper_id: str, offset: int = 0,
     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")
+        md_path = None
+        if paper and paper.get("md_path"):
+            md_path = Path(paper["md_path"])
+            if not md_path.exists() and paper.get("paper_id"):
+                # papers.jsonl records absolute paths from the build machine; the SAME files ship in the
+                # published dataset (publications_md.tar.gz -> parsed_md/<paper_id>/vlm/<paper_id>.md).
+                # Same registry-vs-published-layout mismatch, same fix, as the notebooks below — without
+                # this, every deployment but the build machine got the lossy reconstruction for all
+                # 12,411 papers, verbatim originals for 11,209 of them sitting unread on disk (review).
+                pid = paper["paper_id"]
+                roots = ([Path(os.environ["PUBS_MD_ROOT"])] if os.environ.get("PUBS_MD_ROOT") else []) + [
+                    ROOT.parent.parent / "originals_md" / "publications_md",
+                    ROOT.parent.parent / "originals_md",     # publications_md.tar.gz untarred in place
+                    ROOT.parent.parent / "publications_md"]
+                for root in roots:
+                    cand = root / "parsed_md" / pid / "vlm" / f"{pid}.md"
+                    if cand.exists():
+                        md_path = cand
+                        break
+        if md_path is not None and md_path.exists():
+            text = 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"),
+            out = {"ok": True, "full_text": True, "reconstructed": False, "text_fidelity": "verbatim",
+                   "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),
@@ -890,11 +993,61 @@ def read_publication(doi_or_paper_id: str, offset: int = 0,
                     pos += len(line)
                 out["outline"] = outline[:60]
             return out
-        # not parsed — fall back to registry metadata
+        # No parsed markdown anywhere on disk for this paper. Its text is also in the publications
+        # collection as chunks, so reassemble it from there when a Qdrant server is available. Lossy by
+        # construction — the loader caps a stored chunk at 2500 characters, the chunker drops references
+        # and similar sections and overlaps seams — so the reply says `full_text: false` and marks every
+        # cap-cut in the text itself. A store failure is reported as one, never as "not parsed" (review).
         low = key.lower()
+        chunks, truncated, store_error = _publication_chunks(low)
+        if store_error:
+            return _err(f"cannot read this publication right now: {store_error}",
+                        hint="the publications index did not answer; retry, or check the Qdrant server")
+        kept = [c for c in chunks if c.get("text_raw")]
+        if kept:
+            offset = max(0, int(offset))
+            max_chars = max(1000, min(int(max_chars), 60_000))
+            cap_mark = "[… text missing here: the stored chunk is capped at 2500 characters …]"
+            parts, outline, pos, last_section = [], [], 0, None
+            for c in kept:
+                t = c["text_raw"]
+                sec = str(c.get("section") or "")
+                if sec and sec != last_section:
+                    outline.append({"heading": sec[:120], "offset": pos})
+                    last_section = sec
+                parts.append(t)
+                pos += len(t) + 2
+                if len(t) >= 2500:          # the loader's cap: the cut is real and it is marked in-line
+                    parts.append(cap_mark)
+                    pos += len(cap_mark) + 2
+            text = "\n\n".join(parts)
+            page = text[offset:offset + max_chars]
+            first = kept[0]
+            reg = next((r for r in _registry() if (r.get("doi") or "").lower() == low), None) or {}
+            unordered = sum(1 for c in kept if _chunk_order(c) == _ORDER_UNKNOWN)
+            out = {"ok": True, "full_text": False, "reconstructed": True,
+                   "text_fidelity": "reconstructed-lossy", "truncated": truncated,
+                   "source": "reassembled from publication chunks (lossy: stored chunk text is capped — "
+                             "cuts are marked in-line — references/boilerplate are dropped at chunking, "
+                             "and seams may repeat a sentence)",
+                   "outline": outline[:60],
+                   "doi": first.get("doi") or reg.get("doi") or key, "title": first.get("title"),
+                   "journal": first.get("journal"), "year": first.get("year"),
+                   "authors": reg.get("authors"), "abstract": reg.get("abstract"),
+                   "pdf_status": reg.get("pdf_status"),
+                   "linked_products": (first.get("linked_products") or reg.get("linked_products") or [])[:15],
+                   "n_chunks": len(kept), "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 unordered:
+                out["order_uncertain"] = (f"{unordered} of {len(kept)} chunks carry no usable order key "
+                                          f"and were appended at the end in storage order")
+            return out
+        # nothing parsed and nothing indexed — fall back to registry metadata
         rec = next((r for r in _registry() if r["doi"].lower() == low), None)
         if rec:
-            return {"ok": True, "full_text": False,
+            return {"ok": True, "full_text": False, "text_fidelity": "metadata-only",
                     "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"),
@@ -1002,6 +1155,21 @@ def get_dataset_code(dataset_id: str, notebook_id: str | None = None,
                 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():
+                # When the parsed trees named in md_path are not present (they are absent from the published
+                # dataset), look for the same file under the published layout: notebook_harvest/parsed/…
+                # lives under originals_md/notebooks/harvest/ and eqc_qa/notebooks_code/… under
+                # originals_md/notebooks/eqc/. The family md_path implies is searched FIRST, so a basename
+                # that ever repeats across families resolves to its own copy, not alphabetically (review).
+                base = ROOT.parent.parent / "originals_md" / "notebooks"
+                mdp = str(rec.get("md_path") or "")
+                fam = "eqc" if mdp.startswith("eqc_qa/") else \
+                    "harvest" if mdp.startswith("notebook_harvest/") else None
+                alt = sorted((base / fam).rglob(f"{notebook_id}.md")) if fam else []
+                if not alt:
+                    alt = sorted(base.rglob(f"{notebook_id}.md"))
+                if alt:
+                    path = alt[0]
             if not path.exists():
                 return _err(f"notebook file missing on disk: {path.name}")
             text = path.read_text(encoding="utf-8", errors="replace")